src/backend/tcop/postgres.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * postgres.c
   4  *        POSTGRES C Backend Interface
   5  *
   6  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.258 2002/03/21 16:01:25 tgl Exp $
  12  *
  13  * NOTES
  14  *        this is the "main" module of the postgres backend and
  15  *        hence the main module of the "traffic cop".
  16  *
  17  *-------------------------------------------------------------------------
  18  */
  19
  20 #include "postgres.h"
  21
  22 #include <unistd.h>
  23 #include <signal.h>
  24 #include <time.h>
  25 #include <sys/time.h>
  26 #include <sys/types.h>
  27 #include <fcntl.h>
  28 #include <sys/socket.h>
  29 #include <errno.h>
  30 #if HAVE_SYS_SELECT_H
  31 #include <sys/select.h>
  32 #endif
  33 #ifdef HAVE_GETOPT_H
  34 #include <getopt.h>
  35 #endif
  36
  37 #include "access/xlog.h"
  38 #include "commands/async.h"
  39 #include "commands/trigger.h"
  40 #include "commands/variable.h"
  41 #include "libpq/libpq.h"
  42 #include "libpq/pqformat.h"
  43 #include "libpq/pqsignal.h"
  44 #include "miscadmin.h"
  45 #include "nodes/print.h"
  46 #include "optimizer/cost.h"
  47 #include "optimizer/planner.h"
  48 #include "parser/analyze.h"
  49 #include "parser/parse.h"
  50 #include "parser/parser.h"
  51 #include "rewrite/rewriteHandler.h"
  52 #include "tcop/fastpath.h"
  53 #include "tcop/pquery.h"
  54 #include "tcop/tcopprot.h"
  55 #include "tcop/utility.h"
  56 #include "storage/proc.h"
  57 #include "utils/exc.h"
  58 #include "utils/guc.h"
  59 #include "utils/memutils.h"
  60 #include "utils/ps_status.h"
  61 #ifdef MULTIBYTE
  62 #include "mb/pg_wchar.h"
  63 #endif
  64
  65 #include "pgstat.h"
  66
  67
  68 /* ----------------
  69  *              global variables
  70  * ----------------
  71  */
  72
  73 extern int      optind;
  74 extern char *optarg;
  75
  76 char       *debug_query_string; /* used by pgmonitor */
  77
  78 /* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
  79 CommandDest whereToSendOutput = Debug;
  80
  81 static bool dontExecute = false;
  82
  83 /* note: these declarations had better match tcopprot.h */
  84 sigjmp_buf      Warn_restart;
  85
  86 bool            Warn_restart_ready = false;
  87 bool            InError = false;
  88
  89 static bool EchoQuery = false;  /* default don't echo */
  90
  91 /*
  92  * Flag to mark SIGHUP. Whenever the main loop comes around it
  93  * will reread the configuration file. (Better than doing the
  94  * reading in the signal handler, ey?)
  95  */
  96 static volatile bool got_SIGHUP = false;
  97
  98 /* ----------------
  99  *              people who want to use EOF should #define DONTUSENEWLINE in
 100  *              tcop/tcopdebug.h
 101  * ----------------
 102  */
 103 #ifndef TCOP_DONTUSENEWLINE
 104 int                     UseNewLine = 1;         /* Use newlines query delimiters (the
 105                                                                  * default) */
 106
 107 #else
 108 int                     UseNewLine = 0;         /* Use EOF as query delimiters */
 109 #endif   /* TCOP_DONTUSENEWLINE */
 110
 111 /*
 112 ** Flags for expensive function optimization -- JMH 3/9/92
 113 */
 114 int                     XfuncMode = 0;
 115
 116 /* ----------------------------------------------------------------
 117  *              decls for routines only used in this file
 118  * ----------------------------------------------------------------
 119  */
 120 static int      InteractiveBackend(StringInfo inBuf);
 121 static int      SocketBackend(StringInfo inBuf);
 122 static int      ReadCommand(StringInfo inBuf);
 123 static List *pg_parse_query(char *query_string, Oid *typev, int nargs);
 124 static List *pg_analyze_and_rewrite(Node *parsetree);
 125 static void start_xact_command(void);
 126 static void finish_xact_command(void);
 127 static void SigHupHandler(SIGNAL_ARGS);
 128 static void FloatExceptionHandler(SIGNAL_ARGS);
 129 static const char *CreateCommandTag(Node *parsetree);
 130
 131
 132 /* ----------------------------------------------------------------
 133  *              routines to obtain user input
 134  * ----------------------------------------------------------------
 135  */
 136
 137 /* ----------------
 138  *      InteractiveBackend() is called for user interactive connections
 139  *      the string entered by the user is placed in its parameter inBuf.
 140  *
 141  *      EOF is returned if end-of-file input is seen; time to shut down.
 142  * ----------------
 143  */
 144
 145 static int
 146 InteractiveBackend(StringInfo inBuf)
 147 {
 148         int                     c;                              /* character read from getc() */
 149         bool            end = false;    /* end-of-input flag */
 150         bool            backslashSeen = false;  /* have we seen a \ ? */
 151
 152         /*
 153          * display a prompt and obtain input from the user
 154          */
 155         printf("backend> ");
 156         fflush(stdout);
 157
 158         /* Reset inBuf to empty */
 159         inBuf->len = 0;
 160         inBuf->data[0] = '\0';
 161
 162         for (;;)
 163         {
 164                 if (UseNewLine)
 165                 {
 166                         /*
 167                          * if we are using \n as a delimiter, then read characters
 168                          * until the \n.
 169                          */
 170                         while ((c = getc(stdin)) != EOF)
 171                         {
 172                                 if (c == '\n')
 173                                 {
 174                                         if (backslashSeen)
 175                                         {
 176                                                 /* discard backslash from inBuf */
 177                                                 inBuf->data[--inBuf->len] = '\0';
 178                                                 backslashSeen = false;
 179                                                 continue;
 180                                         }
 181                                         else
 182                                         {
 183                                                 /* keep the newline character */
 184                                                 appendStringInfoChar(inBuf, '\n');
 185                                                 break;
 186                                         }
 187                                 }
 188                                 else if (c == '\\')
 189                                         backslashSeen = true;
 190                                 else
 191                                         backslashSeen = false;
 192
 193                                 appendStringInfoChar(inBuf, (char) c);
 194                         }
 195
 196                         if (c == EOF)
 197                                 end = true;
 198                 }
 199                 else
 200                 {
 201                         /*
 202                          * otherwise read characters until EOF.
 203                          */
 204                         while ((c = getc(stdin)) != EOF)
 205                                 appendStringInfoChar(inBuf, (char) c);
 206
 207                         if (inBuf->len == 0)
 208                                 end = true;
 209                 }
 210
 211                 if (end)
 212                         return EOF;
 213
 214                 /*
 215                  * otherwise we have a user query so process it.
 216                  */
 217                 break;
 218         }
 219
 220         /*
 221          * if the query echo flag was given, print the query..
 222          */
 223         if (EchoQuery)
 224                 printf("query: %s\n", inBuf->data);
 225         fflush(stdout);
 226
 227         return 'Q';
 228 }
 229
 230 /* ----------------
 231  *      SocketBackend()         Is called for frontend-backend connections
 232  *
 233  *      If the input is a query (case 'Q') then the string entered by
 234  *      the user is placed in its parameter inBuf.
 235  *
 236  *      If the input is a fastpath function call (case 'F') then
 237  *      the function call is processed in HandleFunctionRequest()
 238  *      (now called from PostgresMain()).
 239  *
 240  *      EOF is returned if the connection is lost.
 241  * ----------------
 242  */
 243
 244 static int
 245 SocketBackend(StringInfo inBuf)
 246 {
 247         int                     qtype;
 248
 249         /*
 250          * get input from the frontend
 251          */
 252         qtype = pq_getbyte();
 253
 254         switch (qtype)
 255         {
 256                 case EOF:
 257                         /* frontend disconnected */
 258                         break;
 259
 260                         /*
 261                          * 'Q': user entered a query
 262                          */
 263                 case 'Q':
 264                         if (pq_getstr(inBuf))
 265                                 return EOF;
 266                         break;
 267
 268                         /*
 269                          * 'F':  calling user/system functions
 270                          */
 271                 case 'F':
 272                         if (pq_getstr(inBuf))
 273                                 return EOF;             /* ignore "string" at start of F message */
 274                         break;
 275
 276                         /*
 277                          * 'X':  frontend is exiting
 278                          */
 279                 case 'X':
 280                         break;
 281
 282                         /*
 283                          * otherwise we got garbage from the frontend.
 284                          *
 285                          * XXX are we certain that we want to do an elog(FATAL) here?
 286                          * -cim 1/24/90
 287                          */
 288                 default:
 289                         elog(FATAL, "Socket command type %c unknown", qtype);
 290                         break;
 291         }
 292
 293         return qtype;
 294 }
 295
 296 /* ----------------
 297  *              ReadCommand reads a command from either the frontend or
 298  *              standard input, places it in inBuf, and returns a char
 299  *              representing whether the string is a 'Q'uery or a 'F'astpath
 300  *              call.  EOF is returned if end of file.
 301  * ----------------
 302  */
 303 static int
 304 ReadCommand(StringInfo inBuf)
 305 {
 306         int                     result;
 307
 308         if (IsUnderPostmaster)
 309                 result = SocketBackend(inBuf);
 310         else
 311                 result = InteractiveBackend(inBuf);
 312         return result;
 313 }
 314
 315
 316 /*
 317  * Parse a query string and pass it through the rewriter.
 318  *
 319  * A list of Query nodes is returned, since the string might contain
 320  * multiple queries and/or the rewriter might expand one query to several.
 321  *
 322  * NOTE: this routine is no longer used for processing interactive queries,
 323  * but it is still needed for parsing of SQL function bodies.
 324  */
 325 List *
 326 pg_parse_and_rewrite(char *query_string,                /* string to execute */
 327                                          Oid *typev,    /* parameter types */
 328                                          int nargs) /* number of parameters */
 329 {
 330         List       *raw_parsetree_list;
 331         List       *querytree_list;
 332         List       *list_item;
 333
 334         /*
 335          * (1) parse the request string into a list of raw parse trees.
 336          */
 337         raw_parsetree_list = pg_parse_query(query_string, typev, nargs);
 338
 339         /*
 340          * (2) Do parse analysis and rule rewrite.
 341          */
 342         querytree_list = NIL;
 343         foreach(list_item, raw_parsetree_list)
 344         {
 345                 Node       *parsetree = (Node *) lfirst(list_item);
 346
 347                 querytree_list = nconc(querytree_list,
 348                                                            pg_analyze_and_rewrite(parsetree));
 349         }
 350
 351         return querytree_list;
 352 }
 353
 354 /*
 355  * Do raw parsing (only).
 356  *
 357  * A list of parsetrees is returned, since there might be multiple
 358  * commands in the given string.
 359  *
 360  * NOTE: for interactive queries, it is important to keep this routine
 361  * separate from the analysis & rewrite stages.  Analysis and rewriting
 362  * cannot be done in an aborted transaction, since they require access to
 363  * database tables.  So, we rely on the raw parser to determine whether
 364  * we've seen a COMMIT or ABORT command; when we are in abort state, other
 365  * commands are not processed any further than the raw parse stage.
 366  */
 367 static List *
 368 pg_parse_query(char *query_string, Oid *typev, int nargs)
 369 {
 370         List       *raw_parsetree_list;
 371
 372         if (Debug_print_query)
 373                 elog(LOG, "query: %s", query_string);
 374
 375         if (Show_parser_stats)
 376                 ResetUsage();
 377
 378         raw_parsetree_list = parser(query_string, typev, nargs);
 379
 380         if (Show_parser_stats)
 381                 ShowUsage("PARSER STATISTICS");
 382
 383         return raw_parsetree_list;
 384 }
 385
 386 /*
 387  * Given a raw parsetree (gram.y output), perform parse analysis and
 388  * rule rewriting.
 389  *
 390  * A list of Query nodes is returned, since either the analyzer or the
 391  * rewriter might expand one query to several.
 392  *
 393  * NOTE: for reasons mentioned above, this must be separate from raw parsing.
 394  */
 395 static List *
 396 pg_analyze_and_rewrite(Node *parsetree)
 397 {
 398         List       *querytree_list;
 399         List       *list_item;
 400         Query      *querytree;
 401         List       *new_list;
 402
 403         /*
 404          * (1) Perform parse analysis.
 405          */
 406         if (Show_parser_stats)
 407                 ResetUsage();
 408
 409         querytree_list = parse_analyze(parsetree, NULL);
 410
 411         if (Show_parser_stats)
 412         {
 413                 ShowUsage("PARSE ANALYSIS STATISTICS");
 414                 ResetUsage();
 415         }
 416
 417         /*
 418          * (2) Rewrite the queries, as necessary
 419          *
 420          * rewritten queries are collected in new_list.  Note there may be more
 421          * or fewer than in the original list.
 422          */
 423         new_list = NIL;
 424         foreach(list_item, querytree_list)
 425         {
 426                 querytree = (Query *) lfirst(list_item);
 427
 428                 if (Debug_print_parse)
 429                 {
 430                         if (Debug_pretty_print)
 431                         {
 432                                 elog(LOG, "parse tree:");
 433                                 nodeDisplay(querytree);
 434                         }
 435                         else
 436                                 elog(LOG, "parse tree: %s", nodeToString(querytree));
 437                 }
 438
 439                 if (querytree->commandType == CMD_UTILITY)
 440                 {
 441                         /* don't rewrite utilities, just dump 'em into new_list */
 442                         new_list = lappend(new_list, querytree);
 443                 }
 444                 else
 445                 {
 446                         /* rewrite regular queries */
 447                         List       *rewritten = QueryRewrite(querytree);
 448
 449                         new_list = nconc(new_list, rewritten);
 450                 }
 451         }
 452
 453         querytree_list = new_list;
 454
 455         if (Show_parser_stats)
 456                 ShowUsage("REWRITER STATISTICS");
 457
 458 #ifdef COPY_PARSE_PLAN_TREES
 459
 460         /*
 461          * Optional debugging check: pass querytree output through
 462          * copyObject()
 463          */
 464         new_list = (List *) copyObject(querytree_list);
 465         /* This checks both copyObject() and the equal() routines... */
 466         if (!equal(new_list, querytree_list))
 467                 elog(WARNING, "pg_analyze_and_rewrite: copyObject failed on parse tree");
 468         else
 469                 querytree_list = new_list;
 470 #endif
 471
 472         if (Debug_print_rewritten)
 473         {
 474                 if (Debug_pretty_print)
 475                 {
 476                         elog(LOG, "rewritten parse tree:");
 477                         foreach(list_item, querytree_list)
 478                         {
 479                                 querytree = (Query *) lfirst(list_item);
 480                                 nodeDisplay(querytree);
 481                                 printf("\n");
 482                         }
 483                 }
 484                 else
 485                 {
 486                         elog(LOG, "rewritten parse tree:");
 487                         foreach(list_item, querytree_list)
 488                         {
 489                                 querytree = (Query *) lfirst(list_item);
 490                                 elog(LOG, "%s", nodeToString(querytree));
 491                         }
 492                 }
 493         }
 494
 495         return querytree_list;
 496 }
 497
 498
 499 /* Generate a plan for a single query. */
 500 Plan *
 501 pg_plan_query(Query *querytree)
 502 {
 503         Plan       *plan;
 504
 505         /* Utility commands have no plans. */
 506         if (querytree->commandType == CMD_UTILITY)
 507                 return NULL;
 508
 509         if (Show_planner_stats)
 510                 ResetUsage();
 511
 512         /* call that optimizer */
 513         plan = planner(querytree);
 514
 515         if (Show_planner_stats)
 516                 ShowUsage("PLANNER STATISTICS");
 517
 518 #ifdef COPY_PARSE_PLAN_TREES
 519         /* Optional debugging check: pass plan output through copyObject() */
 520         {
 521                 Plan       *new_plan = (Plan *) copyObject(plan);
 522
 523                 /*
 524                  * equal() currently does not have routines to compare Plan nodes,
 525                  * so don't try to test equality here.  Perhaps fix someday?
 526                  */
 527 #ifdef NOT_USED
 528                 /* This checks both copyObject() and the equal() routines... */
 529                 if (!equal(new_plan, plan))
 530                         elog(WARNING, "pg_plan_query: copyObject failed on plan tree");
 531                 else
 532 #endif
 533                         plan = new_plan;
 534         }
 535 #endif
 536
 537         /*
 538          * Print plan if debugging.
 539          */
 540         if (Debug_print_plan)
 541         {
 542                 if (Debug_pretty_print)
 543                 {
 544                         elog(LOG, "plan:");
 545                         nodeDisplay(plan);
 546                 }
 547                 else
 548                         elog(LOG, "plan: %s", nodeToString(plan));
 549         }
 550
 551         return plan;
 552 }
 553
 554
 555 /* ----------------------------------------------------------------
 556  *              pg_exec_query_string()
 557  *
 558  *              Takes a querystring, runs the parser/utilities or
 559  *              parser/planner/executor over it as necessary.
 560  *
 561  * Assumptions:
 562  *
 563  * At call, we are not inside a transaction command.
 564  *
 565  * The CurrentMemoryContext after starting a transaction command must be
 566  * appropriate for execution of individual queries (typically this will be
 567  * TransactionCommandContext).  Note that this routine resets that context
 568  * after each individual query, so don't store anything there that
 569  * must outlive the call!
 570  *
 571  * parse_context references a context suitable for holding the
 572  * parse/rewrite trees (typically this will be QueryContext).
 573  * This context *must* be longer-lived than the transaction context!
 574  * In fact, if the query string might contain BEGIN/COMMIT commands,
 575  * parse_context had better outlive TopTransactionContext!
 576  *
 577  * We could have hard-wired knowledge about QueryContext and
 578  * TransactionCommandContext into this routine, but it seems better
 579  * not to, in case callers from outside this module need to use some
 580  * other contexts.
 581  *
 582  * ----------------------------------------------------------------
 583  */
 584
 585 void
 586 pg_exec_query_string(char *query_string,                /* string to execute */
 587                                          CommandDest dest,      /* where results should go */
 588                                          MemoryContext parse_context)           /* context for
 589                                                                                                                  * parsetrees */
 590 {
 591         bool            xact_started;
 592         MemoryContext oldcontext;
 593         List       *parsetree_list,
 594                            *parsetree_item;
 595
 596         debug_query_string = query_string;      /* used by pgmonitor */
 597
 598         /*
 599          * Start up a transaction command.      All queries generated by the
 600          * query_string will be in this same command block, *unless* we find a
 601          * BEGIN/COMMIT/ABORT statement; we have to force a new xact command
 602          * after one of those, else bad things will happen in xact.c. (Note
 603          * that this will possibly change current memory context.)
 604          */
 605         start_xact_command();
 606         xact_started = true;
 607
 608         /*
 609          * parse_context *must* be different from the execution memory
 610          * context, else the context reset at the bottom of the loop will
 611          * destroy the parsetree list.  (We really ought to check that
 612          * parse_context isn't a child of CurrentMemoryContext either, but
 613          * that would take more cycles than it's likely to be worth.)
 614          */
 615         Assert(parse_context != CurrentMemoryContext);
 616
 617         /*
 618          * Switch to appropriate context for constructing parsetrees.
 619          */
 620         oldcontext = MemoryContextSwitchTo(parse_context);
 621
 622         /*
 623          * Do basic parsing of the query or queries (this should be safe even
 624          * if we are in aborted transaction state!)
 625          */
 626         parsetree_list = pg_parse_query(query_string, NULL, 0);
 627
 628         /*
 629          * Switch back to execution context to enter the loop.
 630          */
 631         MemoryContextSwitchTo(oldcontext);
 632
 633         /*
 634          * Run through the parsetree(s) and process each one.
 635          */
 636         foreach(parsetree_item, parsetree_list)
 637         {
 638                 Node       *parsetree = (Node *) lfirst(parsetree_item);
 639                 bool            isTransactionStmt;
 640                 const char *commandTag;
 641                 char            completionTag[COMPLETION_TAG_BUFSIZE];
 642                 List       *querytree_list,
 643                                    *querytree_item;
 644
 645                 /* Transaction control statements need some special handling */
 646                 isTransactionStmt = IsA(parsetree, TransactionStmt);
 647
 648                 /*
 649                  * First we set the command-completion tag to the main query
 650                  * (as opposed to each of the others that may be generated by
 651                  * analyze and rewrite).  Also set ps_status and do any special
 652                  * start-of-SQL-command processing needed by the destination.
 653                  */
 654                 commandTag = CreateCommandTag(parsetree);
 655
 656                 set_ps_display(commandTag);
 657
 658                 BeginCommand(commandTag, dest);
 659
 660                 /*
 661                  * If we are in an aborted transaction, ignore all commands except
 662                  * COMMIT/ABORT.  It is important that this test occur before we
 663                  * try to do parse analysis, rewrite, or planning, since all those
 664                  * phases try to do database accesses, which may fail in abort
 665                  * state. (It might be safe to allow some additional utility
 666                  * commands in this state, but not many...)
 667                  */
 668                 if (IsAbortedTransactionBlockState())
 669                 {
 670                         bool            allowit = false;
 671
 672                         if (isTransactionStmt)
 673                         {
 674                                 TransactionStmt *stmt = (TransactionStmt *) parsetree;
 675
 676                                 switch (stmt->command)
 677                                 {
 678                                         case COMMIT:
 679                                         case ROLLBACK:
 680                                                 allowit = true;
 681                                                 break;
 682                                         default:
 683                                                 break;
 684                                 }
 685                         }
 686
 687                         if (!allowit)
 688                         {
 689                                 elog(WARNING, "current transaction is aborted, "
 690                                          "queries ignored until end of transaction block");
 691
 692                                 /*
 693                                  * We need to emit a command-complete report to the client,
 694                                  * even though we didn't process the query.
 695                                  * - cim 6/1/90
 696                                  */
 697                                 commandTag = "*ABORT STATE*";
 698
 699                                 EndCommand(commandTag, dest);
 700
 701                                 /*
 702                                  * We continue in the loop, on the off chance that there
 703                                  * is a COMMIT or ROLLBACK utility command later in the
 704                                  * query string.
 705                                  */
 706                                 continue;
 707                         }
 708                 }
 709
 710                 /* Make sure we are in a transaction command */
 711                 if (!xact_started)
 712                 {
 713                         start_xact_command();
 714                         xact_started = true;
 715                 }
 716
 717                 /* If we got a cancel signal in parsing or prior command, quit */
 718                 CHECK_FOR_INTERRUPTS();
 719
 720                 /*
 721                  * OK to analyze and rewrite this query.
 722                  *
 723                  * Switch to appropriate context for constructing querytrees (again,
 724                  * these must outlive the execution context).
 725                  */
 726                 oldcontext = MemoryContextSwitchTo(parse_context);
 727
 728                 querytree_list = pg_analyze_and_rewrite(parsetree);
 729
 730                 /*
 731                  * Switch back to execution context for planning and execution.
 732                  */
 733                 MemoryContextSwitchTo(oldcontext);
 734
 735                 /*
 736                  * Inner loop handles the individual queries generated from a
 737                  * single parsetree by analysis and rewrite.
 738                  */
 739                 foreach(querytree_item, querytree_list)
 740                 {
 741                         Query      *querytree = (Query *) lfirst(querytree_item);
 742
 743                         /* Make sure we are in a transaction command */
 744                         if (!xact_started)
 745                         {
 746                                 start_xact_command();
 747                                 xact_started = true;
 748                         }
 749
 750                         /*
 751                          * If we got a cancel signal in analysis or prior command,
 752                          * quit
 753                          */
 754                         CHECK_FOR_INTERRUPTS();
 755
 756                         if (querytree->commandType == CMD_UTILITY)
 757                         {
 758                                 /*
 759                                  * process utility functions (create, destroy, etc..)
 760                                  */
 761                                 if (Debug_print_query)
 762                                         elog(LOG, "ProcessUtility: %s", query_string);
 763                                 else elog(DEBUG2, "ProcessUtility");
 764
 765                                 if (querytree->originalQuery)
 766                                 {
 767                                         /* utility statement can override default tag string */
 768                                         ProcessUtility(querytree->utilityStmt, dest,
 769                                                                    completionTag);
 770                                         if (completionTag[0])
 771                                                 commandTag = completionTag;
 772                                 }
 773                                 else
 774                                 {
 775                                         /* utility added by rewrite cannot override tag */
 776                                         ProcessUtility(querytree->utilityStmt, dest, NULL);
 777                                 }
 778                         }
 779                         else
 780                         {
 781                                 /*
 782                                  * process a plannable query.
 783                                  */
 784                                 Plan       *plan;
 785
 786                                 plan = pg_plan_query(querytree);
 787
 788                                 /* if we got a cancel signal whilst planning, quit */
 789                                 CHECK_FOR_INTERRUPTS();
 790
 791                                 /* Initialize snapshot state for query */
 792                                 SetQuerySnapshot();
 793
 794                                 /*
 795                                  * execute the plan
 796                                  */
 797                                 if (Show_executor_stats)
 798                                         ResetUsage();
 799
 800                                 if (dontExecute)
 801                                 {
 802                                         /* don't execute it, just show the query plan */
 803                                         print_plan(plan, querytree);
 804                                 }
 805                                 else
 806                                 {
 807                                         elog(DEBUG2, "ProcessQuery");
 808
 809                                         if (querytree->originalQuery)
 810                                         {
 811                                                 /* original stmt can override default tag string */
 812                                                 ProcessQuery(querytree, plan, dest, completionTag);
 813                                                 commandTag = completionTag;
 814                                         }
 815                                         else
 816                                         {
 817                                                 /* stmt added by rewrite cannot override tag */
 818                                                 ProcessQuery(querytree, plan, dest, NULL);
 819                                         }
 820                                 }
 821
 822                                 if (Show_executor_stats)
 823                                         ShowUsage("EXECUTOR STATISTICS");
 824                         }
 825
 826                         /*
 827                          * In a query block, we want to increment the command counter
 828                          * between queries so that the effects of early queries are
 829                          * visible to subsequent ones.  In particular we'd better do
 830                          * so before checking constraints.
 831                          */
 832                         if (!isTransactionStmt)
 833                                 CommandCounterIncrement();
 834
 835                         /*
 836                          * Clear the execution context to recover temporary memory
 837                          * used by the query.  NOTE: if query string contains
 838                          * BEGIN/COMMIT transaction commands, execution context may
 839                          * now be different from what we were originally passed; so be
 840                          * careful to clear current context not "oldcontext".
 841                          */
 842                         Assert(parse_context != CurrentMemoryContext);
 843
 844                         MemoryContextResetAndDeleteChildren(CurrentMemoryContext);
 845
 846                         /*
 847                          * If this was a transaction control statement, commit it and
 848                          * arrange to start a new xact command for the next command
 849                          * (if any).
 850                          */
 851                         if (isTransactionStmt)
 852                         {
 853                                 finish_xact_command();
 854                                 xact_started = false;
 855                         }
 856
 857                 }                                               /* end loop over queries generated from a
 858                                                                  * parsetree */
 859
 860                 /*
 861                  * If this is the last parsetree of the query string, close down
 862                  * transaction statement before reporting command-complete.  This is
 863                  * so that any end-of-transaction errors are reported before the
 864                  * command-complete message is issued, to avoid confusing clients
 865                  * who will expect either a command-complete message or an error,
 866                  * not one and then the other.  But for compatibility with
 867                  * historical Postgres behavior, we do not force a transaction
 868                  * boundary between queries appearing in a single query string.
 869                  */
 870                 if (lnext(parsetree_item) == NIL && xact_started)
 871                 {
 872                         finish_xact_command();
 873                         xact_started = false;
 874                 }
 875
 876                 /*
 877                  * It is possible that the original query was removed due to
 878                  * a DO INSTEAD rewrite rule.  In that case we will still have
 879                  * the default completion tag, which is fine for most purposes,
 880                  * but it may confuse clients if it's INSERT/UPDATE/DELETE.
 881                  * Clients expect those tags to have counts after them (cf.
 882                  * ProcessQuery).
 883                  */
 884                 if (strcmp(commandTag, "INSERT") == 0)
 885                         commandTag = "INSERT 0 0";
 886                 else if (strcmp(commandTag, "UPDATE") == 0)
 887                         commandTag = "UPDATE 0";
 888                 else if (strcmp(commandTag, "DELETE") == 0)
 889                         commandTag = "DELETE 0";
 890
 891                 /*
 892                  * Tell client that we're done with this query.  Note we emit
 893                  * exactly one EndCommand report for each raw parsetree, thus
 894                  * one for each SQL command the client sent, regardless of
 895                  * rewriting.  (But a command aborted by error will not send
 896                  * an EndCommand report at all.)
 897                  */
 898                 EndCommand(commandTag, dest);
 899         }                                                       /* end loop over parsetrees */
 900
 901         /*
 902          * Close down transaction statement, if one is open.
 903          * (Note that this will only happen if the querystring was empty.)
 904          */
 905         if (xact_started)
 906                 finish_xact_command();
 907
 908         debug_query_string = NULL;      /* used by pgmonitor */
 909 }
 910
 911 /*
 912  * Convenience routines for starting/committing a single command.
 913  */
 914 static void
 915 start_xact_command(void)
 916 {
 917         elog(DEBUG1, "StartTransactionCommand");
 918         StartTransactionCommand();
 919 }
 920
 921 static void
 922 finish_xact_command(void)
 923 {
 924         /* Invoke IMMEDIATE constraint triggers */
 925         DeferredTriggerEndQuery();
 926
 927         /* Now commit the command */
 928         elog(DEBUG1, "CommitTransactionCommand");
 929
 930         CommitTransactionCommand();
 931
 932 #ifdef SHOW_MEMORY_STATS
 933         /* Print mem stats at each commit for leak tracking */
 934         if (ShowStats)
 935                 MemoryContextStats(TopMemoryContext);
 936 #endif
 937 }
 938
 939
 940 /* --------------------------------
 941  *              signal handler routines used in PostgresMain()
 942  * --------------------------------
 943  */
 944
 945 /*
 946  * quickdie() occurs when signalled SIGQUIT by the postmaster.
 947  *
 948  * Some backend has bought the farm,
 949  * so we need to stop what we're doing and exit.
 950  */
 951 void
 952 quickdie(SIGNAL_ARGS)
 953 {
 954         PG_SETMASK(&BlockSig);
 955         elog(WARNING, "Message from PostgreSQL backend:"
 956                  "\n\tThe Postmaster has informed me that some other backend"
 957                  "\n\tdied abnormally and possibly corrupted shared memory."
 958                  "\n\tI have rolled back the current transaction and am"
 959            "\n\tgoing to terminate your database system connection and exit."
 960         "\n\tPlease reconnect to the database system and repeat your query.");
 961
 962         /*
 963          * DO NOT proc_exit() -- we're here because shared memory may be
 964          * corrupted, so we don't want to try to clean up our transaction.
 965          * Just nail the windows shut and get out of town.
 966          *
 967          * Note we do exit(1) not exit(0).      This is to force the postmaster into
 968          * a system reset cycle if some idiot DBA sends a manual SIGQUIT to a
 969          * random backend.      This is necessary precisely because we don't clean
 970          * up our shared memory state.
 971          */
 972
 973         exit(1);
 974 }
 975
 976 /*
 977  * Shutdown signal from postmaster: abort transaction and exit
 978  * at soonest convenient time
 979  */
 980 void
 981 die(SIGNAL_ARGS)
 982 {
 983         int                     save_errno = errno;
 984
 985         /* Don't joggle the elbow of proc_exit */
 986         if (!proc_exit_inprogress)
 987         {
 988                 InterruptPending = true;
 989                 ProcDiePending = true;
 990
 991                 /*
 992                  * If it's safe to interrupt, and we're waiting for input or a
 993                  * lock, service the interrupt immediately
 994                  */
 995                 if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
 996                         CritSectionCount == 0)
 997                 {
 998                         /* bump holdoff count to make ProcessInterrupts() a no-op */
 999                         /* until we are done getting ready for it */
1000                         InterruptHoldoffCount++;
1001                         DisableNotifyInterrupt();
1002                         /* Make sure HandleDeadLock won't run while shutting down... */
1003                         LockWaitCancel();
1004                         InterruptHoldoffCount--;
1005                         ProcessInterrupts();
1006                 }
1007         }
1008
1009         errno = save_errno;
1010 }
1011
1012 /*
1013  * Timeout or shutdown signal from postmaster during client authentication.
1014  * Simply exit(0).
1015  *
1016  * XXX: possible future improvement: try to send a message indicating
1017  * why we are disconnecting.  Problem is to be sure we don't block while
1018  * doing so, nor mess up the authentication message exchange.
1019  */
1020 void
1021 authdie(SIGNAL_ARGS)
1022 {
1023         exit(0);
1024 }
1025
1026 /*
1027  * Query-cancel signal from postmaster: abort current transaction
1028  * at soonest convenient time
1029  */
1030 static void
1031 QueryCancelHandler(SIGNAL_ARGS)
1032 {
1033         int                     save_errno = errno;
1034
1035         /*
1036          * Don't joggle the elbow of proc_exit, nor an already-in-progress
1037          * abort
1038          */
1039         if (!proc_exit_inprogress && !InError)
1040         {
1041                 InterruptPending = true;
1042                 QueryCancelPending = true;
1043
1044                 /*
1045                  * If it's safe to interrupt, and we're waiting for a lock,
1046                  * service the interrupt immediately.  No point in interrupting if
1047                  * we're waiting for input, however.
1048                  */
1049                 if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
1050                         CritSectionCount == 0)
1051                 {
1052                         /* bump holdoff count to make ProcessInterrupts() a no-op */
1053                         /* until we are done getting ready for it */
1054                         InterruptHoldoffCount++;
1055                         if (LockWaitCancel())
1056                         {
1057                                 DisableNotifyInterrupt();
1058                                 InterruptHoldoffCount--;
1059                                 ProcessInterrupts();
1060                         }
1061                         else
1062                                 InterruptHoldoffCount--;
1063                 }
1064         }
1065
1066         errno = save_errno;
1067 }
1068
1069 /* signal handler for floating point exception */
1070 static void
1071 FloatExceptionHandler(SIGNAL_ARGS)
1072 {
1073         elog(ERROR, "floating point exception!"
1074                  " The last floating point operation either exceeded legal ranges"
1075                  " or was a divide by zero");
1076 }
1077
1078 /* SIGHUP: set flag to re-read config file at next convenient time */
1079 static void
1080 SigHupHandler(SIGNAL_ARGS)
1081 {
1082         got_SIGHUP = true;
1083 }
1084
1085
1086 /*
1087  * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro
1088  *
1089  * If an interrupt condition is pending, and it's safe to service it,
1090  * then clear the flag and accept the interrupt.  Called only when
1091  * InterruptPending is true.
1092  */
1093 void
1094 ProcessInterrupts(void)
1095 {
1096         /* OK to accept interrupt now? */
1097         if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
1098                 return;
1099         InterruptPending = false;
1100         if (ProcDiePending)
1101         {
1102                 ProcDiePending = false;
1103                 QueryCancelPending = false;             /* ProcDie trumps QueryCancel */
1104                 ImmediateInterruptOK = false;   /* not idle anymore */
1105                 elog(FATAL, "This connection has been terminated by the administrator.");
1106         }
1107         if (QueryCancelPending)
1108         {
1109                 QueryCancelPending = false;
1110                 ImmediateInterruptOK = false;   /* not idle anymore */
1111                 elog(ERROR, "Query was cancelled.");
1112         }
1113         /* If we get here, do nothing (probably, QueryCancelPending was reset) */
1114 }
1115
1116
1117 static void
1118 usage(char *progname)
1119 {
1120         printf("%s is the PostgreSQL stand-alone backend.  It is not\nintended to be used by normal users.\n\n", progname);
1121
1122         printf("Usage:\n  %s [options...] [dbname]\n\n", progname);
1123         printf("Options:\n");
1124 #ifdef USE_ASSERT_CHECKING
1125         printf("  -A 1|0          enable/disable run-time assert checking\n");
1126 #endif
1127         printf("  -B NBUFFERS     number of shared buffers (default %d)\n", DEF_NBUFFERS);
1128         printf("  -c NAME=VALUE   set run-time parameter\n");
1129         printf("  -d 1-5,0        debugging level (0 is off)\n");
1130         printf("  -D DATADIR      database directory\n");
1131         printf("  -e              use European date format\n");
1132         printf("  -E              echo query before execution\n");
1133         printf("  -F              turn fsync off\n");
1134         printf("  -N              do not use newline as interactive query delimiter\n");
1135         printf("  -o FILENAME     send stdout and stderr to given file\n");
1136         printf("  -P              disable system indexes\n");
1137         printf("  -s              show statistics after each query\n");
1138         printf("  -S SORT-MEM     set amount of memory for sorts (in kbytes)\n");
1139         printf("Developer options:\n");
1140         printf("  -f [s|i|n|m|h]  forbid use of some plan types\n");
1141         printf("  -i              do not execute queries\n");
1142         printf("  -O              allow system table structure changes\n");
1143         printf("  -t [pa|pl|ex]   show timings after each query\n");
1144         printf("  -W NUM          wait NUM seconds to allow attach from a debugger\n");
1145         printf("\nReport bugs to <pgsql-bugs@postgresql.org>.\n");
1146 }
1147
1148
1149
1150 /* ----------------------------------------------------------------
1151  * PostgresMain
1152  *         postgres main loop -- all backends, interactive or otherwise start here
1153  *
1154  * argc/argv are the command line arguments to be used.  (When being forked
1155  * by the postmaster, these are not the original argv array of the process.)
1156  * username is the (possibly authenticated) PostgreSQL user name to be used
1157  * for the session.
1158  * ----------------------------------------------------------------
1159  */
1160 int
1161 PostgresMain(int argc, char *argv[], const char *username)
1162 {
1163         int                     flag;
1164
1165         const char *DBName = NULL;
1166         bool            secure;
1167         int                     errs = 0;
1168         GucContext      ctx;
1169         GucSource       gucsource;
1170         char       *tmp;
1171
1172         int                     firstchar;
1173         StringInfo      parser_input;
1174
1175         char       *potential_DataDir = NULL;
1176
1177         /*
1178          * Catch standard options before doing much else.  This even works on
1179          * systems without getopt_long.
1180          */
1181         if (!IsUnderPostmaster && argc > 1)
1182         {
1183                 if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
1184                 {
1185                         usage(argv[0]);
1186                         exit(0);
1187                 }
1188                 if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
1189                 {
1190                         puts("postgres (PostgreSQL) " PG_VERSION);
1191                         exit(0);
1192                 }
1193         }
1194
1195         /*
1196          * Fire up essential subsystems: error and memory management
1197          *
1198          * If we are running under the postmaster, this is done already.
1199          */
1200         if (!IsUnderPostmaster)
1201         {
1202                 EnableExceptionHandling(true);
1203                 MemoryContextInit();
1204         }
1205
1206         set_ps_display("startup");
1207
1208         SetProcessingMode(InitProcessing);
1209
1210         /*
1211          * Set default values for command-line options.
1212          */
1213         Noversion = false;
1214         EchoQuery = false;
1215
1216         if (!IsUnderPostmaster)
1217         {
1218                 ResetAllOptions(true);
1219                 potential_DataDir = getenv("PGDATA");
1220         }
1221
1222         /* Check for PGDATESTYLE environment variable */
1223         set_default_datestyle();
1224
1225         /* ----------------
1226          *      parse command line arguments
1227          *
1228          *      There are now two styles of command line layout for the backend:
1229          *
1230          *      For interactive use (not started from postmaster) the format is
1231          *              postgres [switches] [databasename]
1232          *      If the databasename is omitted it is taken to be the user name.
1233          *
1234          *      When started from the postmaster, the format is
1235          *              postgres [secure switches] -p databasename [insecure switches]
1236          *      Switches appearing after -p came from the client (via "options"
1237          *      field of connection request).  For security reasons we restrict
1238          *      what these switches can do.
1239          * ----------------
1240          */
1241
1242         /* all options are allowed until '-p' */
1243         secure = true;
1244         ctx = PGC_POSTMASTER;
1245         gucsource = PGC_S_ARGV;         /* initial switches came from command line */
1246
1247         while ((flag = getopt(argc, argv, "A:B:c:CD:d:Eef:FiNOPo:p:S:st:v:W:x:-:")) != -1)
1248                 switch (flag)
1249                 {
1250                         case 'A':
1251 #ifdef USE_ASSERT_CHECKING
1252                                 SetConfigOption("debug_assertions", optarg, ctx, gucsource);
1253 #else
1254                                 elog(WARNING, "Assert checking is not compiled in");
1255 #endif
1256                                 break;
1257
1258                         case 'B':
1259
1260                                 /*
1261                                  * specify the size of buffer pool
1262                                  */
1263                                 SetConfigOption("shared_buffers", optarg, ctx, gucsource);
1264                                 break;
1265
1266                         case 'C':
1267
1268                                 /*
1269                                  * don't print version string
1270                                  */
1271                                 Noversion = true;
1272                                 break;
1273
1274                         case 'D':                       /* PGDATA directory */
1275                                 if (secure)
1276                                         potential_DataDir = optarg;
1277                                 break;
1278
1279                         case 'd':                       /* debug level */
1280                                 {
1281                                         /* Set server debugging level. */
1282                                         if (atoi(optarg) != 0)
1283                                         {
1284                                                 char *debugstr = palloc(strlen("debug") + strlen(optarg) + 1);
1285
1286                                                 sprintf(debugstr, "debug%s", optarg);
1287                                                 SetConfigOption("server_min_messages", debugstr, ctx, gucsource);
1288                                                 pfree(debugstr);
1289                                                 /*
1290                                                  * -d is not the same as setting client_min_messages
1291                                                  * because it enables other output options.
1292                                                  */
1293                                                 if (atoi(optarg) >= 1)
1294                                                         SetConfigOption("log_connections", "true", ctx, gucsource);
1295                                                 if (atoi(optarg) >= 2)
1296                                                         SetConfigOption("debug_print_query", "true", ctx, gucsource);
1297                                                 if (atoi(optarg) >= 3)
1298                                                         SetConfigOption("debug_print_parse", "true", ctx, gucsource);
1299                                                 if (atoi(optarg) >= 4)
1300                                                         SetConfigOption("debug_print_plan", "true", ctx, gucsource);
1301                                                 if (atoi(optarg) >= 5)
1302                                                         SetConfigOption("debug_print_rewritten", "true", ctx, gucsource);
1303                                         }
1304                                         else
1305                                                 /*
1306                                                  *      -d 0 allows user to prevent postmaster debug from
1307                                                  *      propogating to backend.
1308                                                  */
1309                                                 SetConfigOption("server_min_messages", "notice", PGC_POSTMASTER, PGC_S_ARGV);
1310                                 }
1311                                 break;
1312
1313                         case 'E':
1314
1315                                 /*
1316                                  * E - echo the query the user entered
1317                                  */
1318                                 EchoQuery = true;
1319                                 break;
1320
1321                         case 'e':
1322
1323                                 /*
1324                                  * Use european date formats.
1325                                  */
1326                                 EuroDates = true;
1327                                 break;
1328
1329                         case 'F':
1330
1331                                 /*
1332                                  * turn off fsync
1333                                  */
1334                                 SetConfigOption("fsync", "false", ctx, gucsource);
1335                                 break;
1336
1337                         case 'f':
1338
1339                                 /*
1340                                  * f - forbid generation of certain plans
1341                                  */
1342                                 tmp = NULL;
1343                                 switch (optarg[0])
1344                                 {
1345                                         case 's':       /* seqscan */
1346                                                 tmp = "enable_seqscan";
1347                                                 break;
1348                                         case 'i':       /* indexscan */
1349                                                 tmp = "enable_indexscan";
1350                                                 break;
1351                                         case 't':       /* tidscan */
1352                                                 tmp = "enable_tidscan";
1353                                                 break;
1354                                         case 'n':       /* nestloop */
1355                                                 tmp = "enable_nestloop";
1356                                                 break;
1357                                         case 'm':       /* mergejoin */
1358                                                 tmp = "enable_mergejoin";
1359                                                 break;
1360                                         case 'h':       /* hashjoin */
1361                                                 tmp = "enable_hashjoin";
1362                                                 break;
1363                                         default:
1364                                                 errs++;
1365                                 }
1366                                 if (tmp)
1367                                         SetConfigOption(tmp, "false", ctx, gucsource);
1368                                 break;
1369
1370                         case 'i':
1371                                 dontExecute = true;
1372                                 break;
1373
1374                         case 'N':
1375
1376                                 /*
1377                                  * N - Don't use newline as a query delimiter
1378                                  */
1379                                 UseNewLine = 0;
1380                                 break;
1381
1382                         case 'O':
1383
1384                                 /*
1385                                  * allow system table structure modifications
1386                                  */
1387                                 if (secure)             /* XXX safe to allow from client??? */
1388                                         allowSystemTableMods = true;
1389                                 break;
1390
1391                         case 'P':
1392
1393                                 /*
1394                                  * ignore system indexes
1395                                  */
1396                                 if (secure)             /* XXX safe to allow from client??? */
1397                                         IgnoreSystemIndexes(true);
1398                                 break;
1399
1400                         case 'o':
1401
1402                                 /*
1403                                  * o - send output (stdout and stderr) to the given file
1404                                  */
1405                                 if (secure)
1406                                         StrNCpy(OutputFileName, optarg, MAXPGPATH);
1407                                 break;
1408
1409                         case 'p':
1410
1411                                 /*
1412                                  * p - special flag passed if backend was forked by a
1413                                  * postmaster.
1414                                  */
1415                                 if (secure)
1416                                 {
1417                                         DBName = strdup(optarg);
1418                                         secure = false;         /* subsequent switches are NOT
1419                                                                                  * secure */
1420                                         ctx = PGC_BACKEND;
1421                                         gucsource = PGC_S_CLIENT;
1422                                 }
1423                                 break;
1424
1425                         case 'S':
1426
1427                                 /*
1428                                  * S - amount of sort memory to use in 1k bytes
1429                                  */
1430                                 SetConfigOption("sort_mem", optarg, ctx, gucsource);
1431                                 break;
1432
1433                         case 's':
1434
1435                                 /*
1436                                  * s - report usage statistics (timings) after each query
1437                                  */
1438                                 SetConfigOption("show_query_stats", "true", ctx, gucsource);
1439                                 break;
1440
1441                         case 't':
1442                                 /* ---------------
1443                                  *      tell postgres to report usage statistics (timings) for
1444                                  *      each query
1445                                  *
1446                                  *      -tpa[rser] = print stats for parser time of each query
1447                                  *      -tpl[anner] = print stats for planner time of each query
1448                                  *      -te[xecutor] = print stats for executor time of each query
1449                                  *      caution: -s can not be used together with -t.
1450                                  * ----------------
1451                                  */
1452                                 tmp = NULL;
1453                                 switch (optarg[0])
1454                                 {
1455                                         case 'p':
1456                                                 if (optarg[1] == 'a')
1457                                                         tmp = "show_parser_stats";
1458                                                 else if (optarg[1] == 'l')
1459                                                         tmp = "show_planner_stats";
1460                                                 else
1461                                                         errs++;
1462                                                 break;
1463                                         case 'e':
1464                                                 tmp = "show_executor_stats";
1465                                                 break;
1466                                         default:
1467                                                 errs++;
1468                                                 break;
1469                                 }
1470                                 if (tmp)
1471                                         SetConfigOption(tmp, "true", ctx, gucsource);
1472                                 break;
1473
1474                         case 'v':
1475                                 if (secure)
1476                                         FrontendProtocol = (ProtocolVersion) atoi(optarg);
1477                                 break;
1478
1479                         case 'W':
1480
1481                                 /*
1482                                  * wait N seconds to allow attach from a debugger
1483                                  */
1484                                 sleep(atoi(optarg));
1485                                 break;
1486
1487                         case 'x':
1488 #ifdef NOT_USED                                 /* planner/xfunc.h */
1489
1490                                 /*
1491                                  * control joey hellerstein's expensive function
1492                                  * optimization
1493                                  */
1494                                 if (XfuncMode != 0)
1495                                 {
1496                                         elog(WARNING, "only one -x flag is allowed");
1497                                         errs++;
1498                                         break;
1499                                 }
1500                                 if (strcmp(optarg, "off") == 0)
1501                                         XfuncMode = XFUNC_OFF;
1502                                 else if (strcmp(optarg, "nor") == 0)
1503                                         XfuncMode = XFUNC_NOR;
1504                                 else if (strcmp(optarg, "nopull") == 0)
1505                                         XfuncMode = XFUNC_NOPULL;
1506                                 else if (strcmp(optarg, "nopm") == 0)
1507                                         XfuncMode = XFUNC_NOPM;
1508                                 else if (strcmp(optarg, "pullall") == 0)
1509                                         XfuncMode = XFUNC_PULLALL;
1510                                 else if (strcmp(optarg, "wait") == 0)
1511                                         XfuncMode = XFUNC_WAIT;
1512                                 else
1513                                 {
1514                                         elog(WARNING, "use -x {off,nor,nopull,nopm,pullall,wait}");
1515                                         errs++;
1516                                 }
1517 #endif
1518                                 break;
1519
1520                         case 'c':
1521                         case '-':
1522                                 {
1523                                         char       *name,
1524                                                            *value;
1525
1526                                         ParseLongOption(optarg, &name, &value);
1527                                         if (!value)
1528                                         {
1529                                                 if (flag == '-')
1530                                                         elog(ERROR, "--%s requires argument", optarg);
1531                                                 else
1532                                                         elog(ERROR, "-c %s requires argument", optarg);
1533                                         }
1534
1535                                         SetConfigOption(name, value, ctx, gucsource);
1536                                         free(name);
1537                                         if (value)
1538                                                 free(value);
1539                                         break;
1540                                 }
1541
1542                         default:
1543                                 errs++;
1544                                 break;
1545                 }
1546
1547         /*
1548          * Post-processing for command line options.
1549          */
1550         if (Show_query_stats &&
1551                 (Show_parser_stats || Show_planner_stats || Show_executor_stats))
1552         {
1553                 elog(WARNING, "Query statistics are disabled because parser, planner, or executor statistics are on.");
1554                 SetConfigOption("show_query_stats", "false", ctx, gucsource);
1555         }
1556
1557         if (!IsUnderPostmaster)
1558         {
1559                 if (!potential_DataDir)
1560                 {
1561                         fprintf(stderr, "%s does not know where to find the database system "
1562                            "data.  You must specify the directory that contains the "
1563                                 "database system either by specifying the -D invocation "
1564                          "option or by setting the PGDATA environment variable.\n\n",
1565                                         argv[0]);
1566                         proc_exit(1);
1567                 }
1568                 SetDataDir(potential_DataDir);
1569         }
1570         Assert(DataDir);
1571
1572         /*
1573          * Set up signal handlers and masks.
1574          *
1575          * Note that postmaster blocked all signals before forking child process,
1576          * so there is no race condition whereby we might receive a signal
1577          * before we have set up the handler.
1578          *
1579          * Also note: it's best not to use any signals that are SIG_IGNored in
1580          * the postmaster.      If such a signal arrives before we are able to
1581          * change the handler to non-SIG_IGN, it'll get dropped.  Instead,
1582          * make a dummy handler in the postmaster to reserve the signal.
1583          * (Of course, this isn't an issue for signals that are locally generated,
1584          * such as SIGALRM and SIGPIPE.)
1585          */
1586
1587         pqsignal(SIGHUP, SigHupHandler);        /* set flag to read config file */
1588         pqsignal(SIGINT, QueryCancelHandler);           /* cancel current query */
1589         pqsignal(SIGTERM, die);         /* cancel current query and exit */
1590         pqsignal(SIGQUIT, quickdie);    /* hard crash time */
1591         pqsignal(SIGALRM, HandleDeadLock);      /* check for deadlock after
1592                                                                                  * timeout */
1593
1594         /*
1595          * Ignore failure to write to frontend. Note: if frontend closes
1596          * connection, we will notice it and exit cleanly when control next
1597          * returns to outer loop.  This seems safer than forcing exit in the
1598          * midst of output during who-knows-what operation...
1599          */
1600         pqsignal(SIGPIPE, SIG_IGN);
1601         pqsignal(SIGUSR1, SIG_IGN); /* this signal available for use */
1602
1603         pqsignal(SIGUSR2, Async_NotifyHandler);         /* flush also sinval cache */
1604         pqsignal(SIGFPE, FloatExceptionHandler);
1605
1606         /*
1607          * Reset some signals that are accepted by postmaster but not by
1608          * backend
1609          */
1610         pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
1611                                                                  * platforms */
1612
1613         pqinitmask();
1614
1615         /* We allow SIGQUIT (quickdie) at all times */
1616 #ifdef HAVE_SIGPROCMASK
1617         sigdelset(&BlockSig, SIGQUIT);
1618 #else
1619         BlockSig &= ~(sigmask(SIGQUIT));
1620 #endif
1621
1622         PG_SETMASK(&BlockSig);          /* block everything except SIGQUIT */
1623
1624
1625         if (IsUnderPostmaster)
1626         {
1627                 /* noninteractive case: nothing should be left after switches */
1628                 if (errs || argc != optind || DBName == NULL)
1629                 {
1630                         elog(WARNING, "%s: invalid command line arguments\nTry -? for help.",
1631                                  argv[0]);
1632                         proc_exit(0);           /* not 1, that causes system-wide
1633                                                                  * restart... */
1634                 }
1635                 BaseInit();
1636         }
1637         else
1638         {
1639                 /* interactive case: database name can be last arg on command line */
1640                 if (errs || argc - optind > 1)
1641                 {
1642                         elog(WARNING, "%s: invalid command line arguments\nTry -? for help.",
1643                                  argv[0]);
1644                         proc_exit(1);
1645                 }
1646                 else if (argc - optind == 1)
1647                         DBName = argv[optind];
1648                 else if ((DBName = username) == NULL)
1649                 {
1650                         elog(WARNING, "%s: user name undefined and no database specified",
1651                                  argv[0]);
1652                         proc_exit(1);
1653                 }
1654
1655                 /*
1656                  * On some systems our dynloader code needs the executable's
1657                  * pathname.  (If under postmaster, this was done already.)
1658                  */
1659                 if (FindExec(pg_pathname, argv[0], "postgres") < 0)
1660                         elog(FATAL, "%s: could not locate executable, bailing out...",
1661                                  argv[0]);
1662
1663                 /*
1664                  * Validate we have been given a reasonable-looking DataDir (if
1665                  * under postmaster, assume postmaster did this already).
1666                  */
1667                 ValidatePgVersion(DataDir);
1668
1669                 /*
1670                  * Create lockfile for data directory.
1671                  */
1672                 if (!CreateDataDirLockFile(DataDir, false))
1673                         proc_exit(1);
1674
1675                 XLOGPathInit();
1676                 BaseInit();
1677
1678                 /*
1679                  * Start up xlog for standalone backend, and register to have it
1680                  * closed down at exit.
1681                  */
1682                 StartupXLOG();
1683                 on_shmem_exit(ShutdownXLOG, 0);
1684         }
1685
1686         /*
1687          * Set up additional info.
1688          */
1689
1690 #ifdef CYR_RECODE
1691         SetCharSet();
1692 #endif
1693
1694         /*
1695          * General initialization.
1696          *
1697          * NOTE: if you are tempted to add code in this vicinity, consider
1698          * putting it inside InitPostgres() instead.  In particular, anything
1699          * that involves database access should be there, not here.
1700          */
1701         elog(DEBUG2, "InitPostgres");
1702         InitPostgres(DBName, username);
1703
1704         SetProcessingMode(NormalProcessing);
1705
1706         /*
1707          * Send this backend's cancellation info to the frontend.
1708          */
1709         if (whereToSendOutput == Remote &&
1710                 PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
1711         {
1712                 StringInfoData buf;
1713
1714                 pq_beginmessage(&buf);
1715                 pq_sendbyte(&buf, 'K');
1716                 pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
1717                 pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
1718                 pq_endmessage(&buf);
1719                 /* Need not flush since ReadyForQuery will do it. */
1720         }
1721
1722         if (!IsUnderPostmaster)
1723         {
1724                 puts("\nPOSTGRES backend interactive interface ");
1725                 puts("$Revision: 1.258 $ $Date: 2002/03/21 16:01:25 $\n");
1726         }
1727
1728         /*
1729          * Create the memory context we will use in the main loop.
1730          *
1731          * QueryContext is reset once per iteration of the main loop, ie, upon
1732          * completion of processing of each supplied query string. It can
1733          * therefore be used for any data that should live just as long as the
1734          * query string --- parse trees, for example.
1735          */
1736         QueryContext = AllocSetContextCreate(TopMemoryContext,
1737                                                                                  "QueryContext",
1738                                                                                  ALLOCSET_DEFAULT_MINSIZE,
1739                                                                                  ALLOCSET_DEFAULT_INITSIZE,
1740                                                                                  ALLOCSET_DEFAULT_MAXSIZE);
1741
1742         /* ----------
1743          * Tell the statistics collector that we're alive and
1744          * to which database we belong.
1745          * ----------
1746          */
1747         pgstat_bestart();
1748
1749         /*
1750          * POSTGRES main processing loop begins here
1751          *
1752          * If an exception is encountered, processing resumes here so we abort
1753          * the current transaction and start a new one.
1754          */
1755
1756         if (sigsetjmp(Warn_restart, 1) != 0)
1757         {
1758                 /*
1759                  * NOTE: if you are tempted to add more code in this if-block,
1760                  * consider the probability that it should be in
1761                  * AbortTransaction() instead.
1762                  *
1763                  * Make sure we're not interrupted while cleaning up.  Also forget
1764                  * any pending QueryCancel request, since we're aborting anyway.
1765                  * Force InterruptHoldoffCount to a known state in case we elog'd
1766                  * from inside a holdoff section.
1767                  */
1768                 ImmediateInterruptOK = false;
1769                 QueryCancelPending = false;
1770                 InterruptHoldoffCount = 1;
1771                 CritSectionCount = 0;   /* should be unnecessary, but... */
1772                 debug_query_string = NULL;              /* used by pgmonitor */
1773
1774                 /*
1775                  * Make sure we are in a valid memory context during recovery.
1776                  *
1777                  * We use ErrorContext in hopes that it will have some free space
1778                  * even if we're otherwise up against it...
1779                  */
1780                 MemoryContextSwitchTo(ErrorContext);
1781
1782                 /* Do the recovery */
1783                 elog(DEBUG1, "AbortCurrentTransaction");
1784                 AbortCurrentTransaction();
1785
1786                 /*
1787                  * Now return to normal top-level context and clear ErrorContext
1788                  * for next time.
1789                  */
1790                 MemoryContextSwitchTo(TopMemoryContext);
1791                 MemoryContextResetAndDeleteChildren(ErrorContext);
1792
1793                 /*
1794                  * Clear flag to indicate that we got out of error recovery mode
1795                  * successfully.  (Flag was set in elog.c before longjmp().)
1796                  */
1797                 InError = false;
1798
1799                 /*
1800                  * Exit interrupt holdoff section we implicitly established above.
1801                  */
1802                 RESUME_INTERRUPTS();
1803         }
1804
1805         Warn_restart_ready = true;      /* we can now handle elog(ERROR) */
1806
1807         PG_SETMASK(&UnBlockSig);
1808
1809         /*
1810          * Non-error queries loop here.
1811          */
1812
1813         for (;;)
1814         {
1815                 /*
1816                  * Release storage left over from prior query cycle, and create a
1817                  * new query input buffer in the cleared QueryContext.
1818                  */
1819                 MemoryContextSwitchTo(QueryContext);
1820                 MemoryContextResetAndDeleteChildren(QueryContext);
1821
1822                 parser_input = makeStringInfo();
1823
1824                 /*
1825                  * (1) tell the frontend we're ready for a new query.
1826                  *
1827                  * Note: this includes fflush()'ing the last of the prior output.
1828                  */
1829                 ReadyForQuery(whereToSendOutput);
1830
1831                 /* ----------
1832                  * Tell the statistics collector what we've collected
1833                  * so far.
1834                  * ----------
1835                  */
1836                 pgstat_report_tabstat();
1837
1838                 if (IsTransactionBlock())
1839                 {
1840                         set_ps_display("idle in transaction");
1841                         pgstat_report_activity("<IDLE> in transaction");
1842                 }
1843                 else
1844                 {
1845                         set_ps_display("idle");
1846                         pgstat_report_activity("<IDLE>");
1847                 }
1848
1849                 /*
1850                  * (2) deal with pending asynchronous NOTIFY from other backends,
1851                  * and enable async.c's signal handler to execute NOTIFY directly.
1852                  * Then set up other stuff needed before blocking for input.
1853                  */
1854                 QueryCancelPending = false;             /* forget any earlier CANCEL
1855                                                                                  * signal */
1856
1857                 EnableNotifyInterrupt();
1858
1859                 /* Allow "die" interrupt to be processed while waiting */
1860                 ImmediateInterruptOK = true;
1861                 /* and don't forget to detect one that already arrived */
1862                 QueryCancelPending = false;
1863                 CHECK_FOR_INTERRUPTS();
1864
1865                 /*
1866                  * (3) read a command (loop blocks here)
1867                  */
1868                 firstchar = ReadCommand(parser_input);
1869
1870                 /*
1871                  * (4) disable async signal conditions again.
1872                  */
1873                 ImmediateInterruptOK = false;
1874                 QueryCancelPending = false;             /* forget any CANCEL signal */
1875
1876                 DisableNotifyInterrupt();
1877
1878                 /*
1879                  * (5) check for any other interesting events that happened while
1880                  * we slept.
1881                  */
1882                 if (got_SIGHUP)
1883                 {
1884                         got_SIGHUP = false;
1885                         ProcessConfigFile(PGC_SIGHUP);
1886                 }
1887
1888                 /*
1889                  * (6) process the command.
1890                  */
1891                 switch (firstchar)
1892                 {
1893                                 /*
1894                                  * 'F' indicates a fastpath call.
1895                                  */
1896                         case 'F':
1897                                 /* ----------
1898                                  * Tell the collector what we're doing
1899                                  * ----------
1900                                  */
1901                                 pgstat_report_activity("<FASTPATH> function call");
1902
1903                                 /* start an xact for this function invocation */
1904                                 start_xact_command();
1905
1906                                 if (HandleFunctionRequest() == EOF)
1907                                 {
1908                                         /* lost frontend connection during F message input */
1909                                         /*
1910                                          * Reset whereToSendOutput to prevent elog from attempting
1911                                          * to send any more messages to client.
1912                                          */
1913                                         if (whereToSendOutput == Remote)
1914                                                 whereToSendOutput = None;
1915
1916                                         proc_exit(0);
1917                                 }
1918
1919                                 /* commit the function-invocation transaction */
1920                                 finish_xact_command();
1921                                 break;
1922
1923                                 /*
1924                                  * 'Q' indicates a user query
1925                                  */
1926                         case 'Q':
1927                                 if (strspn(parser_input->data, " \t\r\n") == parser_input->len)
1928                                 {
1929                                         /*
1930                                          * if there is nothing in the input buffer, don't
1931                                          * bother trying to parse and execute anything; just
1932                                          * send back a quick NullCommand response.
1933                                          */
1934                                         if (IsUnderPostmaster)
1935                                                 NullCommand(Remote);
1936                                 }
1937                                 else
1938                                 {
1939                                         /*
1940                                          * otherwise, process the input string.
1941                                          *
1942                                          * Note: transaction command start/end is now done within
1943                                          * pg_exec_query_string(), not here.
1944                                          */
1945                                         if (Show_query_stats)
1946                                                 ResetUsage();
1947
1948                                         pgstat_report_activity(parser_input->data);
1949
1950                                         pg_exec_query_string(parser_input->data,
1951                                                                                  whereToSendOutput,
1952                                                                                  QueryContext);
1953
1954                                         if (Show_query_stats)
1955                                                 ShowUsage("QUERY STATISTICS");
1956                                 }
1957                                 break;
1958
1959                                 /*
1960                                  *      'X' means that the frontend is closing down the socket.
1961                                  *      EOF means unexpected loss of frontend connection.
1962                                  *      Either way, perform normal shutdown.
1963                                  */
1964                         case 'X':
1965                         case EOF:
1966                                 /*
1967                                  * Reset whereToSendOutput to prevent elog from attempting
1968                                  * to send any more messages to client.
1969                                  */
1970                                 if (whereToSendOutput == Remote)
1971                                         whereToSendOutput = None;
1972
1973                                 /*
1974                                  * NOTE: if you are tempted to add more code here, DON'T!
1975                                  * Whatever you had in mind to do should be set up as an
1976                                  * on_proc_exit or on_shmem_exit callback, instead.
1977                                  * Otherwise it will fail to be called during other
1978                                  * backend-shutdown scenarios.
1979                                  */
1980                                 proc_exit(0);
1981
1982                         default:
1983                                 elog(ERROR, "unknown frontend message was received");
1984                 }
1985
1986 #ifdef MEMORY_CONTEXT_CHECKING
1987
1988                 /*
1989                  * Check all memory after each backend loop.  This is a rather
1990                  * weird place to do it, perhaps.
1991                  */
1992                 MemoryContextCheck(TopMemoryContext);
1993 #endif
1994         }                                                       /* end of input-reading loop */
1995
1996         /* can't get here because the above loop never exits */
1997         Assert(false);
1998
1999         return 1;                                       /* keep compiler quiet */
2000 }
2001
2002 #ifndef HAVE_GETRUSAGE
2003 #include "rusagestub.h"
2004 #else
2005 #include <sys/resource.h>
2006 #endif   /* HAVE_GETRUSAGE */
2007
2008 struct rusage Save_r;
2009 struct timeval Save_t;
2010
2011 void
2012 ResetUsage(void)
2013 {
2014         struct timezone tz;
2015
2016         getrusage(RUSAGE_SELF, &Save_r);
2017         gettimeofday(&Save_t, &tz);
2018         ResetBufferUsage();
2019 /*        ResetTupleCount(); */
2020 }
2021
2022 void
2023 ShowUsage(const char *title)
2024 {
2025         StringInfoData str;
2026         struct timeval user,
2027                                 sys;
2028         struct timeval elapse_t;
2029         struct timezone tz;
2030         struct rusage r;
2031         char *bufusage;
2032
2033         getrusage(RUSAGE_SELF, &r);
2034         gettimeofday(&elapse_t, &tz);
2035         memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
2036         memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
2037         if (elapse_t.tv_usec < Save_t.tv_usec)
2038         {
2039                 elapse_t.tv_sec--;
2040                 elapse_t.tv_usec += 1000000;
2041         }
2042         if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
2043         {
2044                 r.ru_utime.tv_sec--;
2045                 r.ru_utime.tv_usec += 1000000;
2046         }
2047         if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
2048         {
2049                 r.ru_stime.tv_sec--;
2050                 r.ru_stime.tv_usec += 1000000;
2051         }
2052
2053         /*
2054          * the only stats we don't show here are for memory usage -- i can't
2055          * figure out how to interpret the relevant fields in the rusage
2056          * struct, and they change names across o/s platforms, anyway. if you
2057          * can figure out what the entries mean, you can somehow extract
2058          * resident set size, shared text size, and unshared data and stack
2059          * sizes.
2060          */
2061         initStringInfo(&str);
2062
2063         appendStringInfo(&str, "! system usage stats:\n");
2064         appendStringInfo(&str,
2065                         "!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
2066                         (long int) elapse_t.tv_sec - Save_t.tv_sec,
2067                         (long int) elapse_t.tv_usec - Save_t.tv_usec,
2068                         (long int) r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec,
2069                         (long int) r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec,
2070                         (long int) r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec,
2071                         (long int) r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec);
2072         appendStringInfo(&str,
2073                         "!\t[%ld.%06ld user %ld.%06ld sys total]\n",
2074                         (long int) user.tv_sec,
2075                         (long int) user.tv_usec,
2076                         (long int) sys.tv_sec,
2077                         (long int) sys.tv_usec);
2078 /* BeOS has rusage but only has some fields, and not these... */
2079 #if defined(HAVE_GETRUSAGE)
2080         appendStringInfo(&str,
2081                         "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
2082                         r.ru_inblock - Save_r.ru_inblock,
2083         /* they only drink coffee at dec */
2084                         r.ru_oublock - Save_r.ru_oublock,
2085                         r.ru_inblock, r.ru_oublock);
2086         appendStringInfo(&str,
2087                   "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
2088                         r.ru_majflt - Save_r.ru_majflt,
2089                         r.ru_minflt - Save_r.ru_minflt,
2090                         r.ru_majflt, r.ru_minflt,
2091                         r.ru_nswap - Save_r.ru_nswap,
2092                         r.ru_nswap);
2093         appendStringInfo(&str,
2094          "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
2095                         r.ru_nsignals - Save_r.ru_nsignals,
2096                         r.ru_nsignals,
2097                         r.ru_msgrcv - Save_r.ru_msgrcv,
2098                         r.ru_msgsnd - Save_r.ru_msgsnd,
2099                         r.ru_msgrcv, r.ru_msgsnd);
2100         appendStringInfo(&str,
2101                  "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
2102                         r.ru_nvcsw - Save_r.ru_nvcsw,
2103                         r.ru_nivcsw - Save_r.ru_nivcsw,
2104                         r.ru_nvcsw, r.ru_nivcsw);
2105 #endif   /* HAVE_GETRUSAGE */
2106
2107         bufusage = ShowBufferUsage();
2108         appendStringInfo(&str, "! postgres usage stats:\n%s", bufusage);
2109         pfree(bufusage);
2110
2111         /* remove trailing newline */
2112         if (str.data[str.len-1] == '\n')
2113                 str.data[--str.len] = '\0';
2114
2115         elog(LOG, "%s\n%s", title, str.data);
2116
2117         pfree(str.data);
2118 }
2119
2120 #ifdef NOT_USED
2121 static int
2122 assertEnable(int val)
2123 {
2124         assert_enabled = val;
2125         return val;
2126 }
2127
2128 #ifdef ASSERT_CHECKING_TEST
2129 int
2130 assertTest(int val)
2131 {
2132         Assert(val == 0);
2133
2134         if (assert_enabled)
2135         {
2136                 /* val != 0 should be trapped by previous Assert */
2137                 elog(DEBUG3, "Assert test successful (val = %d)", val);
2138         }
2139         else
2140                 elog(DEBUG3, "Assert checking is disabled (val = %d)", val);
2141
2142         return val;
2143 }
2144 #endif
2145
2146 #endif
2147
2148
2149 /* ----------------------------------------------------------------
2150  *              CreateCommandTag
2151  *
2152  *              utility to get a string representation of the
2153  *              command operation.
2154  * ----------------------------------------------------------------
2155  */
2156 static const char *
2157 CreateCommandTag(Node *parsetree)
2158 {
2159         const char   *tag;
2160
2161         switch (nodeTag(parsetree))
2162         {
2163                 case T_InsertStmt:
2164                         tag = "INSERT";
2165                         break;
2166
2167                 case T_DeleteStmt:
2168                         tag = "DELETE";
2169                         break;
2170
2171                 case T_UpdateStmt:
2172                         tag = "UPDATE";
2173                         break;
2174
2175                 case T_SelectStmt:
2176                         tag = "SELECT";
2177                         break;
2178
2179                 case T_TransactionStmt:
2180                         {
2181                                 TransactionStmt *stmt = (TransactionStmt *) parsetree;
2182
2183                                 switch (stmt->command)
2184                                 {
2185                                         case BEGIN_TRANS:
2186                                                 tag = "BEGIN";
2187                                                 break;
2188
2189                                         case COMMIT:
2190                                                 tag = "COMMIT";
2191                                                 break;
2192
2193                                         case ROLLBACK:
2194                                                 tag = "ROLLBACK";
2195                                                 break;
2196
2197                                         default:
2198                                                 tag = "???";
2199                                                 break;
2200                                 }
2201                         }
2202                         break;
2203
2204                 case T_ClosePortalStmt:
2205                         tag = "CLOSE";
2206                         break;
2207
2208                 case T_FetchStmt:
2209                         {
2210                                 FetchStmt  *stmt = (FetchStmt *) parsetree;
2211                                 tag = (stmt->ismove) ? "MOVE" : "FETCH";
2212                         }
2213                         break;
2214
2215                 case T_CreateDomainStmt:
2216                         tag = "CREATE DOMAIN";
2217                         break;
2218
2219                 case T_CreateSchemaStmt:
2220                         tag = "CREATE";
2221                         break;
2222
2223                 case T_CreateStmt:
2224                         tag = "CREATE";
2225                         break;
2226
2227                 case T_DropStmt:
2228                         tag = "DROP";
2229                         break;
2230
2231                 case T_TruncateStmt:
2232                         tag = "TRUNCATE";
2233                         break;
2234
2235                 case T_CommentStmt:
2236                         tag = "COMMENT";
2237                         break;
2238
2239                 case T_CopyStmt:
2240                         tag = "COPY";
2241                         break;
2242
2243                 case T_RenameStmt:
2244                         tag = "ALTER";
2245                         break;
2246
2247                 case T_AlterTableStmt:
2248                         tag = "ALTER";
2249                         break;
2250
2251                 case T_GrantStmt:
2252                         {
2253                                 GrantStmt  *stmt = (GrantStmt *) parsetree;
2254                                 tag = (stmt->is_grant) ? "GRANT" : "REVOKE";
2255                         }
2256                         break;
2257
2258                 case T_DefineStmt:
2259                         tag = "CREATE";
2260                         break;
2261
2262                 case T_ViewStmt:                /* CREATE VIEW */
2263                         tag = "CREATE";
2264                         break;
2265
2266                 case T_ProcedureStmt:   /* CREATE FUNCTION */
2267                         tag = "CREATE";
2268                         break;
2269
2270                 case T_IndexStmt:               /* CREATE INDEX */
2271                         tag = "CREATE";
2272                         break;
2273
2274                 case T_RuleStmt:                /* CREATE RULE */
2275                         tag = "CREATE";
2276                         break;
2277
2278                 case T_CreateSeqStmt:
2279                         tag = "CREATE";
2280                         break;
2281
2282                 case T_RemoveAggrStmt:
2283                         tag = "DROP";
2284                         break;
2285
2286                 case T_RemoveFuncStmt:
2287                         tag = "DROP";
2288                         break;
2289
2290                 case T_RemoveOperStmt:
2291                         tag = "DROP";
2292                         break;
2293
2294                 case T_VersionStmt:
2295                         tag = "CREATE VERSION";
2296                         break;
2297
2298                 case T_CreatedbStmt:
2299                         tag = "CREATE DATABASE";
2300                         break;
2301
2302                 case T_AlterDatabaseSetStmt:
2303                         tag = "ALTER DATABASE";
2304                         break;
2305
2306                 case T_DropdbStmt:
2307                         tag = "DROP DATABASE";
2308                         break;
2309
2310                 case T_NotifyStmt:
2311                         tag = "NOTIFY";
2312                         break;
2313
2314                 case T_ListenStmt:
2315                         tag = "LISTEN";
2316                         break;
2317
2318                 case T_UnlistenStmt:
2319                         tag = "UNLISTEN";
2320                         break;
2321
2322                 case T_LoadStmt:
2323                         tag = "LOAD";
2324                         break;
2325
2326                 case T_ClusterStmt:
2327                         tag = "CLUSTER";
2328                         break;
2329
2330                 case T_VacuumStmt:
2331                         if (((VacuumStmt *) parsetree)->vacuum)
2332                                 tag = "VACUUM";
2333                         else
2334                                 tag = "ANALYZE";
2335                         break;
2336
2337                 case T_ExplainStmt:
2338                         tag = "EXPLAIN";
2339                         break;
2340
2341 #ifdef NOT_USED
2342                 case T_RecipeStmt:
2343                         tag = "EXECUTE RECIPE";
2344                         break;
2345 #endif
2346
2347                 case T_VariableSetStmt:
2348                         tag = "SET VARIABLE";
2349                         break;
2350
2351                 case T_VariableShowStmt:
2352                         tag = "SHOW VARIABLE";
2353                         break;
2354
2355                 case T_VariableResetStmt:
2356                         tag = "RESET VARIABLE";
2357                         break;
2358
2359                 case T_CreateTrigStmt:
2360                         tag = "CREATE";
2361                         break;
2362
2363                 case T_DropTrigStmt:
2364                         tag = "DROP";
2365                         break;
2366
2367                 case T_CreatePLangStmt:
2368                         tag = "CREATE";
2369                         break;
2370
2371                 case T_DropPLangStmt:
2372                         tag = "DROP";
2373                         break;
2374
2375                 case T_CreateUserStmt:
2376                         tag = "CREATE USER";
2377                         break;
2378
2379                 case T_AlterUserStmt:
2380                         tag = "ALTER USER";
2381                         break;
2382
2383                 case T_AlterUserSetStmt:
2384                         tag = "ALTER USER";
2385                         break;
2386
2387                 case T_DropUserStmt:
2388                         tag = "DROP USER";
2389                         break;
2390
2391                 case T_LockStmt:
2392                         tag = "LOCK TABLE";
2393                         break;
2394
2395                 case T_ConstraintsSetStmt:
2396                         tag = "SET CONSTRAINTS";
2397                         break;
2398
2399                 case T_CreateGroupStmt:
2400                         tag = "CREATE GROUP";
2401                         break;
2402
2403                 case T_AlterGroupStmt:
2404                         tag = "ALTER GROUP";
2405                         break;
2406
2407                 case T_DropGroupStmt:
2408                         tag = "DROP GROUP";
2409                         break;
2410
2411                 case T_CheckPointStmt:
2412                         tag = "CHECKPOINT";
2413                         break;
2414
2415                 case T_ReindexStmt:
2416                         tag = "REINDEX";
2417                         break;
2418
2419                 default:
2420                         elog(LOG, "CreateCommandTag: unknown parse node type %d",
2421                                  nodeTag(parsetree));
2422                         tag = "???";
2423                         break;
2424         }
2425
2426         return tag;
2427 }