granicus.if.org Git - postgresql/blob - src/backend/tcop/postgres.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * postgres.c
   4  *        POSTGRES C Backend Interface
   5  *
   6  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.418 2004/06/03 02:08:03 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 <fcntl.h>
  25 #include <sys/socket.h>
  26 #include <errno.h>
  27 #if HAVE_SYS_SELECT_H
  28 #include <sys/select.h>
  29 #endif
  30 #ifdef HAVE_GETOPT_H
  31 #include <getopt.h>
  32 #endif
  33
  34 #include "access/printtup.h"
  35 #include "access/xlog.h"
  36 #include "catalog/pg_type.h"
  37 #include "commands/async.h"
  38 #include "commands/prepare.h"
  39 #include "commands/trigger.h"
  40 #include "libpq/libpq.h"
  41 #include "libpq/pqformat.h"
  42 #include "libpq/pqsignal.h"
  43 #include "miscadmin.h"
  44 #include "nodes/print.h"
  45 #include "optimizer/cost.h"
  46 #include "optimizer/planner.h"
  47 #include "parser/analyze.h"
  48 #include "parser/parser.h"
  49 #include "rewrite/rewriteHandler.h"
  50 #include "storage/freespace.h"
  51 #include "storage/ipc.h"
  52 #include "storage/pg_shmem.h"
  53 #include "storage/proc.h"
  54 #include "storage/sinval.h"
  55 #include "tcop/fastpath.h"
  56 #include "tcop/pquery.h"
  57 #include "tcop/tcopprot.h"
  58 #include "tcop/utility.h"
  59 #include "utils/guc.h"
  60 #include "utils/lsyscache.h"
  61 #include "utils/memutils.h"
  62 #include "utils/ps_status.h"
  63 #include "mb/pg_wchar.h"
  64
  65 #include "pgstat.h"
  66
  67 extern int      optind;
  68 extern char *optarg;
  69
  70 /* ----------------
  71  *              global variables
  72  * ----------------
  73  */
  74 const char *debug_query_string; /* for pgmonitor and
  75                                                                  * log_min_error_statement */
  76
  77 /* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
  78 CommandDest whereToSendOutput = Debug;
  79
  80 /* note: these declarations had better match tcopprot.h */
  81 sigjmp_buf      Warn_restart;
  82
  83 bool            Warn_restart_ready = false;
  84 bool            InError = false;
  85
  86 /* flag for logging end of session */
  87 bool        Log_disconnections = false;
  88
  89 LogStmtLevel log_statement = LOGSTMT_NONE;
  90
  91 /* GUC variable for maximum stack depth (measured in kilobytes) */
  92 int                     max_stack_depth = 2048;
  93
  94
  95 /* ----------------
  96  *              private variables
  97  * ----------------
  98  */
  99
 100 /* max_stack_depth converted to bytes for speed of checking */
 101 static int      max_stack_depth_bytes = 2048*1024;
 102
 103 /* stack base pointer (initialized by PostgresMain) */
 104 static char *stack_base_ptr = NULL;
 105
 106
 107 /*
 108  * Flag to mark SIGHUP. Whenever the main loop comes around it
 109  * will reread the configuration file. (Better than doing the
 110  * reading in the signal handler, ey?)
 111  */
 112 static volatile sig_atomic_t got_SIGHUP = false;
 113
 114 /*
 115  * Flag to keep track of whether we have started a transaction.
 116  * For extended query protocol this has to be remembered across messages.
 117  */
 118 static bool xact_started = false;
 119
 120 /*
 121  * Flags to implement skip-till-Sync-after-error behavior for messages of
 122  * the extended query protocol.
 123  */
 124 static bool doing_extended_query_message = false;
 125 static bool ignore_till_sync = false;
 126
 127 /*
 128  * If an unnamed prepared statement exists, it's stored here.
 129  * We keep it separate from the hashtable kept by commands/prepare.c
 130  * in order to reduce overhead for short-lived queries.
 131  */
 132 static MemoryContext unnamed_stmt_context = NULL;
 133 static PreparedStatement *unnamed_stmt_pstmt = NULL;
 134
 135
 136 static bool EchoQuery = false;  /* default don't echo */
 137
 138 /*
 139  * people who want to use EOF should #define DONTUSENEWLINE in
 140  * tcop/tcopdebug.h
 141  */
 142 #ifndef TCOP_DONTUSENEWLINE
 143 static int      UseNewLine = 1;         /* Use newlines query delimiters (the
 144                                                                  * default) */
 145
 146 #else
 147 static int      UseNewLine = 0;         /* Use EOF as query delimiters */
 148 #endif   /* TCOP_DONTUSENEWLINE */
 149
 150
 151 /* ----------------------------------------------------------------
 152  *              decls for routines only used in this file
 153  * ----------------------------------------------------------------
 154  */
 155 static int      InteractiveBackend(StringInfo inBuf);
 156 static int      SocketBackend(StringInfo inBuf);
 157 static int      ReadCommand(StringInfo inBuf);
 158 static void start_xact_command(void);
 159 static void finish_xact_command(void);
 160 static void SigHupHandler(SIGNAL_ARGS);
 161 static void FloatExceptionHandler(SIGNAL_ARGS);
 162 static void log_disconnections(int code, Datum arg);
 163
 164
 165 /* ----------------------------------------------------------------
 166  *              routines to obtain user input
 167  * ----------------------------------------------------------------
 168  */
 169
 170 /* ----------------
 171  *      InteractiveBackend() is called for user interactive connections
 172  *
 173  *      the string entered by the user is placed in its parameter inBuf,
 174  *      and we act like a Q message was received.
 175  *
 176  *      EOF is returned if end-of-file input is seen; time to shut down.
 177  * ----------------
 178  */
 179
 180 static int
 181 InteractiveBackend(StringInfo inBuf)
 182 {
 183         int                     c;                              /* character read from getc() */
 184         bool            end = false;    /* end-of-input flag */
 185         bool            backslashSeen = false;  /* have we seen a \ ? */
 186
 187         /*
 188          * display a prompt and obtain input from the user
 189          */
 190         printf("backend> ");
 191         fflush(stdout);
 192
 193         /* Reset inBuf to empty */
 194         inBuf->len = 0;
 195         inBuf->data[0] = '\0';
 196         inBuf->cursor = 0;
 197
 198         for (;;)
 199         {
 200                 if (UseNewLine)
 201                 {
 202                         /*
 203                          * if we are using \n as a delimiter, then read characters
 204                          * until the \n.
 205                          */
 206                         while ((c = getc(stdin)) != EOF)
 207                         {
 208                                 if (c == '\n')
 209                                 {
 210                                         if (backslashSeen)
 211                                         {
 212                                                 /* discard backslash from inBuf */
 213                                                 inBuf->data[--inBuf->len] = '\0';
 214                                                 backslashSeen = false;
 215                                                 continue;
 216                                         }
 217                                         else
 218                                         {
 219                                                 /* keep the newline character */
 220                                                 appendStringInfoChar(inBuf, '\n');
 221                                                 break;
 222                                         }
 223                                 }
 224                                 else if (c == '\\')
 225                                         backslashSeen = true;
 226                                 else
 227                                         backslashSeen = false;
 228
 229                                 appendStringInfoChar(inBuf, (char) c);
 230                         }
 231
 232                         if (c == EOF)
 233                                 end = true;
 234                 }
 235                 else
 236                 {
 237                         /*
 238                          * otherwise read characters until EOF.
 239                          */
 240                         while ((c = getc(stdin)) != EOF)
 241                                 appendStringInfoChar(inBuf, (char) c);
 242
 243                         if (inBuf->len == 0)
 244                                 end = true;
 245                 }
 246
 247                 if (end)
 248                         return EOF;
 249
 250                 /*
 251                  * otherwise we have a user query so process it.
 252                  */
 253                 break;
 254         }
 255
 256         /* Add '\0' to make it look the same as message case. */
 257         appendStringInfoChar(inBuf, (char) '\0');
 258
 259         /*
 260          * if the query echo flag was given, print the query..
 261          */
 262         if (EchoQuery)
 263                 printf("statement: %s\n", inBuf->data);
 264         fflush(stdout);
 265
 266         return 'Q';
 267 }
 268
 269 /* ----------------
 270  *      SocketBackend()         Is called for frontend-backend connections
 271  *
 272  *      Returns the message type code, and loads message body data into inBuf.
 273  *
 274  *      EOF is returned if the connection is lost.
 275  * ----------------
 276  */
 277 static int
 278 SocketBackend(StringInfo inBuf)
 279 {
 280         int                     qtype;
 281
 282         /*
 283          * Get message type code from the frontend.
 284          */
 285         qtype = pq_getbyte();
 286
 287         if (qtype == EOF)                       /* frontend disconnected */
 288         {
 289                 ereport(COMMERROR,
 290                                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
 291                                  errmsg("unexpected EOF on client connection")));
 292                 return qtype;
 293         }
 294
 295         /*
 296          * Validate message type code before trying to read body; if we have
 297          * lost sync, better to say "command unknown" than to run out of
 298          * memory because we used garbage as a length word.
 299          *
 300          * This also gives us a place to set the doing_extended_query_message
 301          * flag as soon as possible.
 302          */
 303         switch (qtype)
 304         {
 305                 case 'Q':                               /* simple query */
 306                         doing_extended_query_message = false;
 307                         if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
 308                         {
 309                                 /* old style without length word; convert */
 310                                 if (pq_getstring(inBuf))
 311                                 {
 312                                         ereport(COMMERROR,
 313                                                         (errcode(ERRCODE_PROTOCOL_VIOLATION),
 314                                                  errmsg("unexpected EOF on client connection")));
 315                                         return EOF;
 316                                 }
 317                         }
 318                         break;
 319
 320                 case 'F':                               /* fastpath function call */
 321                         /* we let fastpath.c cope with old-style input of this */
 322                         doing_extended_query_message = false;
 323                         break;
 324
 325                 case 'X':                               /* terminate */
 326                         doing_extended_query_message = false;
 327                         ignore_till_sync = false;
 328                         break;
 329
 330                 case 'B':                               /* bind */
 331                 case 'C':                               /* close */
 332                 case 'D':                               /* describe */
 333                 case 'E':                               /* execute */
 334                 case 'H':                               /* flush */
 335                 case 'P':                               /* parse */
 336                         doing_extended_query_message = true;
 337                         /* these are only legal in protocol 3 */
 338                         if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
 339                                 ereport(FATAL,
 340                                                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
 341                                          errmsg("invalid frontend message type %d", qtype)));
 342                         break;
 343
 344                 case 'S':                               /* sync */
 345                         /* stop any active skip-till-Sync */
 346                         ignore_till_sync = false;
 347                         /* mark not-extended, so that a new error doesn't begin skip */
 348                         doing_extended_query_message = false;
 349                         /* only legal in protocol 3 */
 350                         if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
 351                                 ereport(FATAL,
 352                                                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
 353                                          errmsg("invalid frontend message type %d", qtype)));
 354                         break;
 355
 356                 case 'd':                               /* copy data */
 357                 case 'c':                               /* copy done */
 358                 case 'f':                               /* copy fail */
 359                         doing_extended_query_message = false;
 360                         /* these are only legal in protocol 3 */
 361                         if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
 362                                 ereport(FATAL,
 363                                                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
 364                                          errmsg("invalid frontend message type %d", qtype)));
 365                         break;
 366
 367                 default:
 368
 369                         /*
 370                          * Otherwise we got garbage from the frontend.  We treat this
 371                          * as fatal because we have probably lost message boundary
 372                          * sync, and there's no good way to recover.
 373                          */
 374                         ereport(FATAL,
 375                                         (errcode(ERRCODE_PROTOCOL_VIOLATION),
 376                                          errmsg("invalid frontend message type %d", qtype)));
 377                         break;
 378         }
 379
 380         /*
 381          * In protocol version 3, all frontend messages have a length word
 382          * next after the type code; we can read the message contents
 383          * independently of the type.
 384          */
 385         if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
 386         {
 387                 if (pq_getmessage(inBuf, 0))
 388                         return EOF;                     /* suitable message already logged */
 389         }
 390
 391         return qtype;
 392 }
 393
 394 /* ----------------
 395  *              ReadCommand reads a command from either the frontend or
 396  *              standard input, places it in inBuf, and returns the
 397  *              message type code (first byte of the message).
 398  *              EOF is returned if end of file.
 399  * ----------------
 400  */
 401 static int
 402 ReadCommand(StringInfo inBuf)
 403 {
 404         int                     result;
 405
 406         if (whereToSendOutput == Remote)
 407                 result = SocketBackend(inBuf);
 408         else
 409                 result = InteractiveBackend(inBuf);
 410         return result;
 411 }
 412
 413
 414 /*
 415  * Parse a query string and pass it through the rewriter.
 416  *
 417  * A list of Query nodes is returned, since the string might contain
 418  * multiple queries and/or the rewriter might expand one query to several.
 419  *
 420  * NOTE: this routine is no longer used for processing interactive queries,
 421  * but it is still needed for parsing of SQL function bodies.
 422  */
 423 List *
 424 pg_parse_and_rewrite(const char *query_string,  /* string to execute */
 425                                          Oid *paramTypes,       /* parameter types */
 426                                          int numParams)         /* number of parameters */
 427 {
 428         List       *raw_parsetree_list;
 429         List       *querytree_list;
 430         ListCell   *list_item;
 431
 432         /*
 433          * (1) parse the request string into a list of raw parse trees.
 434          */
 435         raw_parsetree_list = pg_parse_query(query_string);
 436
 437         /*
 438          * (2) Do parse analysis and rule rewrite.
 439          */
 440         querytree_list = NIL;
 441         foreach(list_item, raw_parsetree_list)
 442         {
 443                 Node       *parsetree = (Node *) lfirst(list_item);
 444
 445                 querytree_list = list_concat(querytree_list,
 446                                                            pg_analyze_and_rewrite(parsetree,
 447                                                                                                           paramTypes,
 448                                                                                                           numParams));
 449         }
 450
 451         return querytree_list;
 452 }
 453
 454 /*
 455  * Do raw parsing (only).
 456  *
 457  * A list of parsetrees is returned, since there might be multiple
 458  * commands in the given string.
 459  *
 460  * NOTE: for interactive queries, it is important to keep this routine
 461  * separate from the analysis & rewrite stages.  Analysis and rewriting
 462  * cannot be done in an aborted transaction, since they require access to
 463  * database tables.  So, we rely on the raw parser to determine whether
 464  * we've seen a COMMIT or ABORT command; when we are in abort state, other
 465  * commands are not processed any further than the raw parse stage.
 466  */
 467 List *
 468 pg_parse_query(const char *query_string)
 469 {
 470         List       *raw_parsetree_list;
 471         ListCell   *parsetree_item;
 472
 473         if (log_statement == LOGSTMT_ALL)
 474                 ereport(LOG,
 475                                 (errmsg("statement: %s", query_string)));
 476
 477         if (log_parser_stats)
 478                 ResetUsage();
 479
 480         raw_parsetree_list = raw_parser(query_string);
 481
 482         /* do log_statement tests for mod and ddl */
 483         if (log_statement == LOGSTMT_MOD ||
 484                 log_statement == LOGSTMT_DDL)
 485         {
 486                 foreach(parsetree_item, raw_parsetree_list)
 487                 {
 488                         Node       *parsetree = (Node *) lfirst(parsetree_item);
 489                         const char *commandTag;
 490
 491                         if (IsA(parsetree, ExplainStmt) &&
 492                                 ((ExplainStmt *)parsetree)->analyze)
 493                                 parsetree = (Node *)(((ExplainStmt *)parsetree)->query);
 494
 495                         if (IsA(parsetree, PrepareStmt))
 496                                 parsetree = (Node *)(((PrepareStmt *)parsetree)->query);
 497
 498                         if (IsA(parsetree, SelectStmt))
 499                                 continue;       /* optimization for frequent command */
 500
 501                         if (log_statement == LOGSTMT_MOD &&
 502                                 (IsA(parsetree, InsertStmt) ||
 503                                  IsA(parsetree, UpdateStmt) ||
 504                                  IsA(parsetree, DeleteStmt) ||
 505                                  IsA(parsetree, TruncateStmt) ||
 506                                  (IsA(parsetree, CopyStmt) &&
 507                                   ((CopyStmt *)parsetree)->is_from)))   /* COPY FROM */
 508                         {
 509                                 ereport(LOG,
 510                                                 (errmsg("statement: %s", query_string)));
 511                                 break;
 512                         }
 513                         commandTag = CreateCommandTag(parsetree);
 514                         if (strncmp(commandTag, "CREATE ", strlen("CREATE ")) == 0 ||
 515                                 strncmp(commandTag, "ALTER ", strlen("ALTER ")) == 0 ||
 516                                 strncmp(commandTag, "DROP ", strlen("DROP ")) == 0 ||
 517                                 IsA(parsetree, GrantStmt) ||    /* GRANT or REVOKE */
 518                                 IsA(parsetree, CommentStmt))
 519                         {
 520                                 ereport(LOG,
 521                                                 (errmsg("statement: %s", query_string)));
 522                                 break;
 523                         }
 524                 }
 525         }
 526
 527         if (log_parser_stats)
 528                 ShowUsage("PARSER STATISTICS");
 529
 530         return raw_parsetree_list;
 531 }
 532
 533 /*
 534  * Given a raw parsetree (gram.y output), and optionally information about
 535  * types of parameter symbols ($n), perform parse analysis and rule rewriting.
 536  *
 537  * A list of Query nodes is returned, since either the analyzer or the
 538  * rewriter might expand one query to several.
 539  *
 540  * NOTE: for reasons mentioned above, this must be separate from raw parsing.
 541  */
 542 List *
 543 pg_analyze_and_rewrite(Node *parsetree, Oid *paramTypes, int numParams)
 544 {
 545         List       *querytree_list;
 546
 547         /*
 548          * (1) Perform parse analysis.
 549          */
 550         if (log_parser_stats)
 551                 ResetUsage();
 552
 553         querytree_list = parse_analyze(parsetree, paramTypes, numParams);
 554
 555         if (log_parser_stats)
 556                 ShowUsage("PARSE ANALYSIS STATISTICS");
 557
 558         /*
 559          * (2) Rewrite the queries, as necessary
 560          */
 561         querytree_list = pg_rewrite_queries(querytree_list);
 562
 563         return querytree_list;
 564 }
 565
 566 /*
 567  * Perform rewriting of a list of queries produced by parse analysis.
 568  */
 569 List *
 570 pg_rewrite_queries(List *querytree_list)
 571 {
 572         List       *new_list = NIL;
 573         ListCell   *list_item;
 574
 575         if (log_parser_stats)
 576                 ResetUsage();
 577
 578         /*
 579          * rewritten queries are collected in new_list.  Note there may be
 580          * more or fewer than in the original list.
 581          */
 582         foreach(list_item, querytree_list)
 583         {
 584                 Query      *querytree = (Query *) lfirst(list_item);
 585
 586                 if (Debug_print_parse)
 587                         elog_node_display(DEBUG1, "parse tree", querytree,
 588                                                           Debug_pretty_print);
 589
 590                 if (querytree->commandType == CMD_UTILITY)
 591                 {
 592                         /* don't rewrite utilities, just dump 'em into new_list */
 593                         new_list = lappend(new_list, querytree);
 594                 }
 595                 else
 596                 {
 597                         /* rewrite regular queries */
 598                         List       *rewritten = QueryRewrite(querytree);
 599
 600                         new_list = list_concat(new_list, rewritten);
 601                 }
 602         }
 603
 604         querytree_list = new_list;
 605
 606         if (log_parser_stats)
 607                 ShowUsage("REWRITER STATISTICS");
 608
 609 #ifdef COPY_PARSE_PLAN_TREES
 610
 611         /*
 612          * Optional debugging check: pass querytree output through
 613          * copyObject()
 614          */
 615         new_list = (List *) copyObject(querytree_list);
 616         /* This checks both copyObject() and the equal() routines... */
 617         if (!equal(new_list, querytree_list))
 618                 elog(WARNING, "copyObject() failed to produce an equal parse tree");
 619         else
 620                 querytree_list = new_list;
 621 #endif
 622
 623         if (Debug_print_rewritten)
 624                 elog_node_display(DEBUG1, "rewritten parse tree", querytree_list,
 625                                                   Debug_pretty_print);
 626
 627         return querytree_list;
 628 }
 629
 630
 631 /* Generate a plan for a single already-rewritten query. */
 632 Plan *
 633 pg_plan_query(Query *querytree)
 634 {
 635         Plan       *plan;
 636
 637         /* Utility commands have no plans. */
 638         if (querytree->commandType == CMD_UTILITY)
 639                 return NULL;
 640
 641         if (log_planner_stats)
 642                 ResetUsage();
 643
 644         /* call the optimizer */
 645         plan = planner(querytree, false, 0);
 646
 647         if (log_planner_stats)
 648                 ShowUsage("PLANNER STATISTICS");
 649
 650 #ifdef COPY_PARSE_PLAN_TREES
 651         /* Optional debugging check: pass plan output through copyObject() */
 652         {
 653                 Plan       *new_plan = (Plan *) copyObject(plan);
 654
 655                 /*
 656                  * equal() currently does not have routines to compare Plan nodes,
 657                  * so don't try to test equality here.  Perhaps fix someday?
 658                  */
 659 #ifdef NOT_USED
 660                 /* This checks both copyObject() and the equal() routines... */
 661                 if (!equal(new_plan, plan))
 662                         elog(WARNING, "copyObject() failed to produce an equal plan tree");
 663                 else
 664 #endif
 665                         plan = new_plan;
 666         }
 667 #endif
 668
 669         /*
 670          * Print plan if debugging.
 671          */
 672         if (Debug_print_plan)
 673                 elog_node_display(DEBUG1, "plan", plan, Debug_pretty_print);
 674
 675         return plan;
 676 }
 677
 678 /*
 679  * Generate plans for a list of already-rewritten queries.
 680  *
 681  * If needSnapshot is TRUE, we haven't yet set a snapshot for the current
 682  * query.  A snapshot must be set before invoking the planner, since it
 683  * might try to evaluate user-defined functions.  But we must not set a
 684  * snapshot if the list contains only utility statements, because some
 685  * utility statements depend on not having frozen the snapshot yet.
 686  * (We assume that such statements cannot appear together with plannable
 687  * statements in the rewriter's output.)
 688  */
 689 List *
 690 pg_plan_queries(List *querytrees, bool needSnapshot)
 691 {
 692         List       *plan_list = NIL;
 693         ListCell   *query_list;
 694
 695         foreach(query_list, querytrees)
 696         {
 697                 Query      *query = (Query *) lfirst(query_list);
 698                 Plan       *plan;
 699
 700                 if (query->commandType == CMD_UTILITY)
 701                 {
 702                         /* Utility commands have no plans. */
 703                         plan = NULL;
 704                 }
 705                 else
 706                 {
 707                         if (needSnapshot)
 708                         {
 709                                 SetQuerySnapshot();
 710                                 needSnapshot = false;
 711                         }
 712                         plan = pg_plan_query(query);
 713                 }
 714
 715                 plan_list = lappend(plan_list, plan);
 716         }
 717
 718         return plan_list;
 719 }
 720
 721
 722 /*
 723  * exec_simple_query
 724  *
 725  * Execute a "simple Query" protocol message.
 726  */
 727 static void
 728 exec_simple_query(const char *query_string)
 729 {
 730         CommandDest dest = whereToSendOutput;
 731         MemoryContext oldcontext;
 732         List       *parsetree_list;
 733         ListCell   *parsetree_item;
 734         struct timeval start_t,
 735                                 stop_t;
 736         bool            save_log_duration = log_duration;
 737         int                     save_log_min_duration_statement = log_min_duration_statement;
 738         bool            save_log_statement_stats = log_statement_stats;
 739
 740         /*
 741          * Report query to various monitoring facilities.
 742          */
 743         debug_query_string = query_string;
 744
 745         pgstat_report_activity(query_string);
 746
 747         /*
 748          * We use save_log_* so "SET log_duration = true"  and "SET
 749          * log_min_duration_statement = true" don't report incorrect time
 750          * because gettimeofday() wasn't called. Similarly,
 751          * log_statement_stats has to be captured once.
 752          */
 753         if (save_log_duration || save_log_min_duration_statement != -1)
 754                 gettimeofday(&start_t, NULL);
 755
 756         if (save_log_statement_stats)
 757                 ResetUsage();
 758
 759         /*
 760          * Start up a transaction command.      All queries generated by the
 761          * query_string will be in this same command block, *unless* we find a
 762          * BEGIN/COMMIT/ABORT statement; we have to force a new xact command
 763          * after one of those, else bad things will happen in xact.c. (Note
 764          * that this will normally change current memory context.)
 765          */
 766         start_xact_command();
 767
 768         /*
 769          * Zap any pre-existing unnamed statement.      (While not strictly
 770          * necessary, it seems best to define simple-Query mode as if it used
 771          * the unnamed statement and portal; this ensures we recover any
 772          * storage used by prior unnamed operations.)
 773          */
 774         unnamed_stmt_pstmt = NULL;
 775         if (unnamed_stmt_context)
 776         {
 777                 DropDependentPortals(unnamed_stmt_context);
 778                 MemoryContextDelete(unnamed_stmt_context);
 779         }
 780         unnamed_stmt_context = NULL;
 781
 782         /*
 783          * Switch to appropriate context for constructing parsetrees.
 784          */
 785         oldcontext = MemoryContextSwitchTo(MessageContext);
 786
 787         QueryContext = CurrentMemoryContext;
 788
 789         /*
 790          * Do basic parsing of the query or queries (this should be safe even
 791          * if we are in aborted transaction state!)
 792          */
 793         parsetree_list = pg_parse_query(query_string);
 794
 795         /*
 796          * Switch back to transaction context to enter the loop.
 797          */
 798         MemoryContextSwitchTo(oldcontext);
 799
 800         /*
 801          * Run through the raw parsetree(s) and process each one.
 802          */
 803         foreach(parsetree_item, parsetree_list)
 804         {
 805                 Node       *parsetree = (Node *) lfirst(parsetree_item);
 806                 const char *commandTag;
 807                 char            completionTag[COMPLETION_TAG_BUFSIZE];
 808                 List       *querytree_list,
 809                                    *plantree_list;
 810                 Portal          portal;
 811                 DestReceiver *receiver;
 812                 int16           format;
 813
 814                 /*
 815                  * Get the command name for use in status display (it also becomes
 816                  * the default completion tag, down inside PortalRun).  Set
 817                  * ps_status and do any special start-of-SQL-command processing
 818                  * needed by the destination.
 819                  */
 820                 commandTag = CreateCommandTag(parsetree);
 821
 822                 set_ps_display(commandTag);
 823
 824                 BeginCommand(commandTag, dest);
 825
 826                 /*
 827                  * If we are in an aborted transaction, reject all commands except
 828                  * COMMIT/ABORT.  It is important that this test occur before we
 829                  * try to do parse analysis, rewrite, or planning, since all those
 830                  * phases try to do database accesses, which may fail in abort
 831                  * state. (It might be safe to allow some additional utility
 832                  * commands in this state, but not many...)
 833                  */
 834                 if (IsAbortedTransactionBlockState())
 835                 {
 836                         bool            allowit = false;
 837
 838                         if (IsA(parsetree, TransactionStmt))
 839                         {
 840                                 TransactionStmt *stmt = (TransactionStmt *) parsetree;
 841
 842                                 if (stmt->kind == TRANS_STMT_COMMIT ||
 843                                         stmt->kind == TRANS_STMT_ROLLBACK)
 844                                         allowit = true;
 845                         }
 846
 847                         if (!allowit)
 848                                 ereport(ERROR,
 849                                                 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
 850                                                  errmsg("current transaction is aborted, "
 851                                          "commands ignored until end of transaction block")));
 852                 }
 853
 854                 /* Make sure we are in a transaction command */
 855                 start_xact_command();
 856
 857                 /* If we got a cancel signal in parsing or prior command, quit */
 858                 CHECK_FOR_INTERRUPTS();
 859
 860                 /*
 861                  * OK to analyze, rewrite, and plan this query.
 862                  *
 863                  * Switch to appropriate context for constructing querytrees (again,
 864                  * these must outlive the execution context).
 865                  */
 866                 oldcontext = MemoryContextSwitchTo(MessageContext);
 867
 868                 querytree_list = pg_analyze_and_rewrite(parsetree, NULL, 0);
 869
 870                 plantree_list = pg_plan_queries(querytree_list, true);
 871
 872                 /* If we got a cancel signal in analysis or planning, quit */
 873                 CHECK_FOR_INTERRUPTS();
 874
 875                 /*
 876                  * Create unnamed portal to run the query or queries in. If there
 877                  * already is one, silently drop it.
 878                  */
 879                 portal = CreatePortal("", true, true);
 880
 881                 PortalDefineQuery(portal,
 882                                                   query_string,
 883                                                   commandTag,
 884                                                   querytree_list,
 885                                                   plantree_list,
 886                                                   MessageContext);
 887
 888                 /*
 889                  * Start the portal.  No parameters here.
 890                  */
 891                 PortalStart(portal, NULL);
 892
 893                 /*
 894                  * Select the appropriate output format: text unless we are doing
 895                  * a FETCH from a binary cursor.  (Pretty grotty to have to do
 896                  * this here --- but it avoids grottiness in other places.      Ah,
 897                  * the joys of backward compatibility...)
 898                  */
 899                 format = 0;                             /* TEXT is default */
 900                 if (IsA(parsetree, FetchStmt))
 901                 {
 902                         FetchStmt  *stmt = (FetchStmt *) parsetree;
 903
 904                         if (!stmt->ismove)
 905                         {
 906                                 Portal          fportal = GetPortalByName(stmt->portalname);
 907
 908                                 if (PortalIsValid(fportal) &&
 909                                         (fportal->cursorOptions & CURSOR_OPT_BINARY))
 910                                         format = 1; /* BINARY */
 911                         }
 912                 }
 913                 PortalSetResultFormat(portal, 1, &format);
 914
 915                 /*
 916                  * Now we can create the destination receiver object.
 917                  */
 918                 receiver = CreateDestReceiver(dest, portal);
 919
 920                 /*
 921                  * Switch back to transaction context for execution.
 922                  */
 923                 MemoryContextSwitchTo(oldcontext);
 924
 925                 /*
 926                  * Run the portal to completion, and then drop it (and the
 927                  * receiver).
 928                  */
 929                 (void) PortalRun(portal,
 930                                                  FETCH_ALL,
 931                                                  receiver,
 932                                                  receiver,
 933                                                  completionTag);
 934
 935                 (*receiver->rDestroy) (receiver);
 936
 937                 PortalDrop(portal, false);
 938
 939                 if (IsA(parsetree, TransactionStmt))
 940                 {
 941                         /*
 942                          * If this was a transaction control statement, commit it. We
 943                          * will start a new xact command for the next command (if
 944                          * any).
 945                          */
 946                         finish_xact_command();
 947                 }
 948                 else if (lnext(parsetree_item) == NULL)
 949                 {
 950                         /*
 951                          * If this is the last parsetree of the query string, close
 952                          * down transaction statement before reporting
 953                          * command-complete.  This is so that any end-of-transaction
 954                          * errors are reported before the command-complete message is
 955                          * issued, to avoid confusing clients who will expect either a
 956                          * command-complete message or an error, not one and then the
 957                          * other.  But for compatibility with historical Postgres
 958                          * behavior, we do not force a transaction boundary between
 959                          * queries appearing in a single query string.
 960                          */
 961                         finish_xact_command();
 962                 }
 963                 else
 964                 {
 965                         /*
 966                          * We need a CommandCounterIncrement after every query, except
 967                          * those that start or end a transaction block.
 968                          */
 969                         CommandCounterIncrement();
 970                 }
 971
 972                 /*
 973                  * Tell client that we're done with this query.  Note we emit
 974                  * exactly one EndCommand report for each raw parsetree, thus one
 975                  * for each SQL command the client sent, regardless of rewriting.
 976                  * (But a command aborted by error will not send an EndCommand
 977                  * report at all.)
 978                  */
 979                 EndCommand(completionTag, dest);
 980         }                                                       /* end loop over parsetrees */
 981
 982         /*
 983          * Close down transaction statement, if one is open.
 984          */
 985         finish_xact_command();
 986
 987         /*
 988          * If there were no parsetrees, return EmptyQueryResponse message.
 989          */
 990         if (!parsetree_list)
 991                 NullCommand(dest);
 992
 993         QueryContext = NULL;
 994
 995         /*
 996          * Combine processing here as we need to calculate the query duration
 997          * in both instances.
 998          */
 999         if (save_log_duration || save_log_min_duration_statement != -1)
1000         {
1001                 long            usecs;
1002
1003                 gettimeofday(&stop_t, NULL);
1004                 if (stop_t.tv_usec < start_t.tv_usec)
1005                 {
1006                         stop_t.tv_sec--;
1007                         stop_t.tv_usec += 1000000;
1008                 }
1009                 usecs = (long) (stop_t.tv_sec - start_t.tv_sec) * 1000000 + (long) (stop_t.tv_usec - start_t.tv_usec);
1010
1011                 if (save_log_duration)
1012                         ereport(LOG,
1013                                         (errmsg("duration: %ld.%03ld ms",
1014                                                         (long) ((stop_t.tv_sec - start_t.tv_sec) * 1000 +
1015                                                         (stop_t.tv_usec - start_t.tv_usec) / 1000),
1016                                                         (long) (stop_t.tv_usec - start_t.tv_usec) % 1000)));
1017
1018                 /*
1019                  * Output a duration_statement to the log if the query has exceeded
1020                  * the min duration, or if we are to print all durations.
1021                  */
1022                 if (save_log_min_duration_statement == 0 ||
1023                         (save_log_min_duration_statement > 0 &&
1024                          usecs >= save_log_min_duration_statement * 1000))
1025                         ereport(LOG,
1026                                         (errmsg("duration: %ld.%03ld ms  statement: %s",
1027                                                         (long) ((stop_t.tv_sec - start_t.tv_sec) * 1000 +
1028                                                         (stop_t.tv_usec - start_t.tv_usec) / 1000),
1029                                                         (long) (stop_t.tv_usec - start_t.tv_usec) % 1000,
1030                                                         query_string)));
1031         }
1032
1033         if (save_log_statement_stats)
1034                 ShowUsage("QUERY STATISTICS");
1035
1036         debug_query_string = NULL;
1037 }
1038
1039 /*
1040  * exec_parse_message
1041  *
1042  * Execute a "Parse" protocol message.
1043  */
1044 static void
1045 exec_parse_message(const char *query_string,    /* string to execute */
1046                                    const char *stmt_name,               /* name for prepared stmt */
1047                                    Oid *paramTypes,             /* parameter types */
1048                                    int numParams)               /* number of parameters */
1049 {
1050         MemoryContext oldcontext;
1051         List       *parsetree_list;
1052         const char *commandTag;
1053         List       *querytree_list,
1054                            *plantree_list,
1055                            *param_list;
1056         bool            is_named;
1057         bool            save_log_statement_stats = log_statement_stats;
1058
1059         /*
1060          * Report query to various monitoring facilities.
1061          */
1062         debug_query_string = query_string;
1063
1064         pgstat_report_activity(query_string);
1065
1066         set_ps_display("PARSE");
1067
1068         if (save_log_statement_stats)
1069                 ResetUsage();
1070
1071         /*
1072          * Start up a transaction command so we can run parse analysis etc.
1073          * (Note that this will normally change current memory context.)
1074          * Nothing happens if we are already in one.
1075          */
1076         start_xact_command();
1077
1078         /*
1079          * Switch to appropriate context for constructing parsetrees.
1080          *
1081          * We have two strategies depending on whether the prepared statement is
1082          * named or not.  For a named prepared statement, we do parsing in
1083          * MessageContext and copy the finished trees into the prepared
1084          * statement's private context; then the reset of MessageContext
1085          * releases temporary space used by parsing and planning.  For an
1086          * unnamed prepared statement, we assume the statement isn't going to
1087          * hang around long, so getting rid of temp space quickly is probably
1088          * not worth the costs of copying parse/plan trees.  So in this case,
1089          * we set up a special context for the unnamed statement, and do all
1090          * the parsing/planning therein.
1091          */
1092         is_named = (stmt_name[0] != '\0');
1093         if (is_named)
1094         {
1095                 /* Named prepared statement --- parse in MessageContext */
1096                 oldcontext = MemoryContextSwitchTo(MessageContext);
1097         }
1098         else
1099         {
1100                 /* Unnamed prepared statement --- release any prior unnamed stmt */
1101                 unnamed_stmt_pstmt = NULL;
1102                 if (unnamed_stmt_context)
1103                 {
1104                         DropDependentPortals(unnamed_stmt_context);
1105                         MemoryContextDelete(unnamed_stmt_context);
1106                 }
1107                 unnamed_stmt_context = NULL;
1108                 /* create context for parsing/planning */
1109                 unnamed_stmt_context =
1110                         AllocSetContextCreate(TopMemoryContext,
1111                                                                   "unnamed prepared statement",
1112                                                                   ALLOCSET_DEFAULT_MINSIZE,
1113                                                                   ALLOCSET_DEFAULT_INITSIZE,
1114                                                                   ALLOCSET_DEFAULT_MAXSIZE);
1115                 oldcontext = MemoryContextSwitchTo(unnamed_stmt_context);
1116         }
1117
1118         QueryContext = CurrentMemoryContext;
1119
1120         /*
1121          * Do basic parsing of the query or queries (this should be safe even
1122          * if we are in aborted transaction state!)
1123          */
1124         parsetree_list = pg_parse_query(query_string);
1125
1126         /*
1127          * We only allow a single user statement in a prepared statement. This
1128          * is mainly to keep the protocol simple --- otherwise we'd need to
1129          * worry about multiple result tupdescs and things like that.
1130          */
1131         if (list_length(parsetree_list) > 1)
1132                 ereport(ERROR,
1133                                 (errcode(ERRCODE_SYNTAX_ERROR),
1134                                  errmsg("cannot insert multiple commands into a prepared statement")));
1135
1136         if (parsetree_list != NIL)
1137         {
1138                 Node       *parsetree = (Node *) linitial(parsetree_list);
1139                 int                     i;
1140
1141                 /*
1142                  * Get the command name for possible use in status display.
1143                  */
1144                 commandTag = CreateCommandTag(parsetree);
1145
1146                 /*
1147                  * If we are in an aborted transaction, reject all commands except
1148                  * COMMIT/ROLLBACK.  It is important that this test occur before
1149                  * we try to do parse analysis, rewrite, or planning, since all
1150                  * those phases try to do database accesses, which may fail in
1151                  * abort state. (It might be safe to allow some additional utility
1152                  * commands in this state, but not many...)
1153                  */
1154                 if (IsAbortedTransactionBlockState())
1155                 {
1156                         bool            allowit = false;
1157
1158                         if (IsA(parsetree, TransactionStmt))
1159                         {
1160                                 TransactionStmt *stmt = (TransactionStmt *) parsetree;
1161
1162                                 if (stmt->kind == TRANS_STMT_COMMIT ||
1163                                         stmt->kind == TRANS_STMT_ROLLBACK)
1164                                         allowit = true;
1165                         }
1166
1167                         if (!allowit)
1168                                 ereport(ERROR,
1169                                                 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
1170                                                  errmsg("current transaction is aborted, "
1171                                          "commands ignored until end of transaction block")));
1172                 }
1173
1174                 /*
1175                  * OK to analyze, rewrite, and plan this query.  Note that the
1176                  * originally specified parameter set is not required to be
1177                  * complete, so we have to use parse_analyze_varparams().
1178                  */
1179                 if (log_parser_stats)
1180                         ResetUsage();
1181
1182                 querytree_list = parse_analyze_varparams(parsetree,
1183                                                                                                  &paramTypes,
1184                                                                                                  &numParams);
1185
1186                 /*
1187                  * Check all parameter types got determined, and convert array
1188                  * representation to a list for storage.
1189                  */
1190                 param_list = NIL;
1191                 for (i = 0; i < numParams; i++)
1192                 {
1193                         Oid                     ptype = paramTypes[i];
1194
1195                         if (ptype == InvalidOid || ptype == UNKNOWNOID)
1196                                 ereport(ERROR,
1197                                                 (errcode(ERRCODE_INDETERMINATE_DATATYPE),
1198                                   errmsg("could not determine data type of parameter $%d",
1199                                                  i + 1)));
1200                         param_list = lappend_oid(param_list, ptype);
1201                 }
1202
1203                 if (log_parser_stats)
1204                         ShowUsage("PARSE ANALYSIS STATISTICS");
1205
1206                 querytree_list = pg_rewrite_queries(querytree_list);
1207
1208                 plantree_list = pg_plan_queries(querytree_list, true);
1209         }
1210         else
1211         {
1212                 /* Empty input string.  This is legal. */
1213                 commandTag = NULL;
1214                 querytree_list = NIL;
1215                 plantree_list = NIL;
1216                 param_list = NIL;
1217         }
1218
1219         /* If we got a cancel signal in analysis or planning, quit */
1220         CHECK_FOR_INTERRUPTS();
1221
1222         /*
1223          * Store the query as a prepared statement.  See above comments.
1224          */
1225         if (is_named)
1226         {
1227                 StorePreparedStatement(stmt_name,
1228                                                            query_string,
1229                                                            commandTag,
1230                                                            querytree_list,
1231                                                            plantree_list,
1232                                                            param_list);
1233         }
1234         else
1235         {
1236                 PreparedStatement *pstmt;
1237
1238                 pstmt = (PreparedStatement *) palloc0(sizeof(PreparedStatement));
1239                 /* query_string needs to be copied into unnamed_stmt_context */
1240                 pstmt->query_string = pstrdup(query_string);
1241                 /* the rest is there already */
1242                 pstmt->commandTag = commandTag;
1243                 pstmt->query_list = querytree_list;
1244                 pstmt->plan_list = plantree_list;
1245                 pstmt->argtype_list = param_list;
1246                 pstmt->context = unnamed_stmt_context;
1247                 /* Now the unnamed statement is complete and valid */
1248                 unnamed_stmt_pstmt = pstmt;
1249         }
1250
1251         MemoryContextSwitchTo(oldcontext);
1252
1253         QueryContext = NULL;
1254
1255         /*
1256          * We do NOT close the open transaction command here; that only
1257          * happens when the client sends Sync.  Instead, do
1258          * CommandCounterIncrement just in case something happened during
1259          * parse/plan.
1260          */
1261         CommandCounterIncrement();
1262
1263         /*
1264          * Send ParseComplete.
1265          */
1266         if (whereToSendOutput == Remote)
1267                 pq_putemptymessage('1');
1268
1269         if (save_log_statement_stats)
1270                 ShowUsage("PARSE MESSAGE STATISTICS");
1271
1272         debug_query_string = NULL;
1273 }
1274
1275 /*
1276  * exec_bind_message
1277  *
1278  * Process a "Bind" message to create a portal from a prepared statement
1279  */
1280 static void
1281 exec_bind_message(StringInfo input_message)
1282 {
1283         const char *portal_name;
1284         const char *stmt_name;
1285         int                     numPFormats;
1286         int16      *pformats = NULL;
1287         int                     numParams;
1288         int                     numRFormats;
1289         int16      *rformats = NULL;
1290         int                     i;
1291         PreparedStatement *pstmt;
1292         Portal          portal;
1293         ParamListInfo params;
1294
1295         pgstat_report_activity("<BIND>");
1296
1297         set_ps_display("BIND");
1298
1299         /*
1300          * Start up a transaction command so we can call functions etc. (Note
1301          * that this will normally change current memory context.) Nothing
1302          * happens if we are already in one.
1303          */
1304         start_xact_command();
1305
1306         /* Switch back to message context */
1307         MemoryContextSwitchTo(MessageContext);
1308
1309         /* Get the fixed part of the message */
1310         portal_name = pq_getmsgstring(input_message);
1311         stmt_name = pq_getmsgstring(input_message);
1312
1313         /* Get the parameter format codes */
1314         numPFormats = pq_getmsgint(input_message, 2);
1315         if (numPFormats > 0)
1316         {
1317                 pformats = (int16 *) palloc(numPFormats * sizeof(int16));
1318                 for (i = 0; i < numPFormats; i++)
1319                         pformats[i] = pq_getmsgint(input_message, 2);
1320         }
1321
1322         /* Get the parameter value count */
1323         numParams = pq_getmsgint(input_message, 2);
1324
1325         if (numPFormats > 1 && numPFormats != numParams)
1326                 ereport(ERROR,
1327                                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
1328                 errmsg("bind message has %d parameter formats but %d parameters",
1329                            numPFormats, numParams)));
1330
1331         /* Find prepared statement */
1332         if (stmt_name[0] != '\0')
1333                 pstmt = FetchPreparedStatement(stmt_name, true);
1334         else
1335         {
1336                 /* special-case the unnamed statement */
1337                 pstmt = unnamed_stmt_pstmt;
1338                 if (!pstmt)
1339                         ereport(ERROR,
1340                                         (errcode(ERRCODE_UNDEFINED_PSTATEMENT),
1341                                    errmsg("unnamed prepared statement does not exist")));
1342         }
1343
1344         if (numParams != list_length(pstmt->argtype_list))
1345                 ereport(ERROR,
1346                                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
1347                                  errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d",
1348                                         numParams, stmt_name, list_length(pstmt->argtype_list))));
1349
1350         /*
1351          * Create the portal.  Allow silent replacement of an existing portal
1352          * only if the unnamed portal is specified.
1353          */
1354         if (portal_name[0] == '\0')
1355                 portal = CreatePortal(portal_name, true, true);
1356         else
1357                 portal = CreatePortal(portal_name, false, false);
1358
1359         PortalDefineQuery(portal,
1360                                           pstmt->query_string,
1361                                           pstmt->commandTag,
1362                                           pstmt->query_list,
1363                                           pstmt->plan_list,
1364                                           pstmt->context);
1365
1366         /*
1367          * Fetch parameters, if any, and store in the portal's memory context.
1368          *
1369          * In an aborted transaction, we can't risk calling user-defined
1370          * functions, but we can't fail to Bind either, so bind all parameters
1371          * to null values.
1372          */
1373         if (numParams > 0)
1374         {
1375                 bool            isaborted = IsAbortedTransactionBlockState();
1376                 ListCell   *l;
1377                 MemoryContext oldContext;
1378
1379                 oldContext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
1380
1381                 params = (ParamListInfo)
1382                         palloc0((numParams + 1) * sizeof(ParamListInfoData));
1383
1384                 i = 0;
1385                 foreach(l, pstmt->argtype_list)
1386                 {
1387                         Oid                     ptype = lfirst_oid(l);
1388                         int32           plength;
1389                         bool            isNull;
1390
1391                         plength = pq_getmsgint(input_message, 4);
1392                         isNull = (plength == -1);
1393
1394                         if (!isNull)
1395                         {
1396                                 const char *pvalue = pq_getmsgbytes(input_message, plength);
1397
1398                                 if (isaborted)
1399                                 {
1400                                         /* We don't bother to check the format in this case */
1401                                         isNull = true;
1402                                 }
1403                                 else
1404                                 {
1405                                         int16           pformat;
1406                                         StringInfoData pbuf;
1407                                         char            csave;
1408
1409                                         if (numPFormats > 1)
1410                                                 pformat = pformats[i];
1411                                         else if (numPFormats > 0)
1412                                                 pformat = pformats[0];
1413                                         else
1414                                                 pformat = 0;    /* default = text */
1415
1416                                         /*
1417                                          * Rather than copying data around, we just set up a
1418                                          * phony StringInfo pointing to the correct portion of
1419                                          * the message buffer.  We assume we can scribble on
1420                                          * the message buffer so as to maintain the convention
1421                                          * that StringInfos have a trailing null.  This is
1422                                          * grotty but is a big win when dealing with very
1423                                          * large parameter strings.
1424                                          */
1425                                         pbuf.data = (char *) pvalue;
1426                                         pbuf.maxlen = plength + 1;
1427                                         pbuf.len = plength;
1428                                         pbuf.cursor = 0;
1429
1430                                         csave = pbuf.data[plength];
1431                                         pbuf.data[plength] = '\0';
1432
1433                                         if (pformat == 0)
1434                                         {
1435                                                 Oid                     typInput;
1436                                                 Oid                     typElem;
1437                                                 char       *pstring;
1438
1439                                                 getTypeInputInfo(ptype, &typInput, &typElem);
1440
1441                                                 /*
1442                                                  * We have to do encoding conversion before
1443                                                  * calling the typinput routine.
1444                                                  */
1445                                                 pstring = (char *)
1446                                                         pg_client_to_server((unsigned char *) pbuf.data,
1447                                                                                                 plength);
1448                                                 params[i].value =
1449                                                         OidFunctionCall3(typInput,
1450                                                                                          CStringGetDatum(pstring),
1451                                                                                          ObjectIdGetDatum(typElem),
1452                                                                                          Int32GetDatum(-1));
1453                                                 /* Free result of encoding conversion, if any */
1454                                                 if (pstring != pbuf.data)
1455                                                         pfree(pstring);
1456                                         }
1457                                         else if (pformat == 1)
1458                                         {
1459                                                 Oid                     typReceive;
1460                                                 Oid                     typElem;
1461
1462                                                 /*
1463                                                  * Call the parameter type's binary input
1464                                                  * converter
1465                                                  */
1466                                                 getTypeBinaryInputInfo(ptype, &typReceive, &typElem);
1467
1468                                                 params[i].value =
1469                                                         OidFunctionCall2(typReceive,
1470                                                                                          PointerGetDatum(&pbuf),
1471                                                                                          ObjectIdGetDatum(typElem));
1472
1473                                                 /* Trouble if it didn't eat the whole buffer */
1474                                                 if (pbuf.cursor != pbuf.len)
1475                                                         ereport(ERROR,
1476                                                                         (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1477                                                                          errmsg("incorrect binary data format in bind parameter %d",
1478                                                                                         i + 1)));
1479                                         }
1480                                         else
1481                                         {
1482                                                 ereport(ERROR,
1483                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1484                                                                  errmsg("unsupported format code: %d",
1485                                                                                 pformat)));
1486                                         }
1487
1488                                         /* Restore message buffer contents */
1489                                         pbuf.data[plength] = csave;
1490                                 }
1491                         }
1492
1493                         params[i].kind = PARAM_NUM;
1494                         params[i].id = i + 1;
1495                         params[i].isnull = isNull;
1496
1497                         i++;
1498                 }
1499
1500                 params[i].kind = PARAM_INVALID;
1501
1502                 MemoryContextSwitchTo(oldContext);
1503         }
1504         else
1505                 params = NULL;
1506
1507         /* Get the result format codes */
1508         numRFormats = pq_getmsgint(input_message, 2);
1509         if (numRFormats > 0)
1510         {
1511                 rformats = (int16 *) palloc(numRFormats * sizeof(int16));
1512                 for (i = 0; i < numRFormats; i++)
1513                         rformats[i] = pq_getmsgint(input_message, 2);
1514         }
1515
1516         pq_getmsgend(input_message);
1517
1518         /*
1519          * Start portal execution.
1520          */
1521         PortalStart(portal, params);
1522
1523         /*
1524          * Apply the result format requests to the portal.
1525          */
1526         PortalSetResultFormat(portal, numRFormats, rformats);
1527
1528         /*
1529          * Send BindComplete.
1530          */
1531         if (whereToSendOutput == Remote)
1532                 pq_putemptymessage('2');
1533 }
1534
1535 /*
1536  * exec_execute_message
1537  *
1538  * Process an "Execute" message for a portal
1539  */
1540 static void
1541 exec_execute_message(const char *portal_name, long max_rows)
1542 {
1543         CommandDest dest;
1544         DestReceiver *receiver;
1545         Portal          portal;
1546         bool            is_trans_stmt = false;
1547         bool            is_trans_exit = false;
1548         bool            completed;
1549         char            completionTag[COMPLETION_TAG_BUFSIZE];
1550
1551         /* Adjust destination to tell printtup.c what to do */
1552         dest = whereToSendOutput;
1553         if (dest == Remote)
1554                 dest = RemoteExecute;
1555
1556         portal = GetPortalByName(portal_name);
1557         if (!PortalIsValid(portal))
1558                 ereport(ERROR,
1559                                 (errcode(ERRCODE_UNDEFINED_CURSOR),
1560                                  errmsg("portal \"%s\" does not exist", portal_name)));
1561
1562         /*
1563          * If the original query was a null string, just return
1564          * EmptyQueryResponse.
1565          */
1566         if (portal->commandTag == NULL)
1567         {
1568                 Assert(portal->parseTrees == NIL);
1569                 NullCommand(dest);
1570                 return;
1571         }
1572
1573         if (portal->sourceText)
1574         {
1575                 debug_query_string = portal->sourceText;
1576                 pgstat_report_activity(portal->sourceText);
1577         }
1578         else
1579         {
1580                 debug_query_string = "execute message";
1581                 pgstat_report_activity("<EXECUTE>");
1582         }
1583
1584         set_ps_display(portal->commandTag);
1585
1586         BeginCommand(portal->commandTag, dest);
1587
1588         /* Check for transaction-control commands */
1589         if (list_length(portal->parseTrees) == 1)
1590         {
1591                 Query      *query = (Query *) linitial(portal->parseTrees);
1592
1593                 if (query->commandType == CMD_UTILITY &&
1594                         query->utilityStmt != NULL &&
1595                         IsA(query->utilityStmt, TransactionStmt))
1596                 {
1597                         TransactionStmt *stmt = (TransactionStmt *) query->utilityStmt;
1598
1599                         is_trans_stmt = true;
1600                         if (stmt->kind == TRANS_STMT_COMMIT ||
1601                                 stmt->kind == TRANS_STMT_ROLLBACK)
1602                                 is_trans_exit = true;
1603                 }
1604         }
1605
1606         /*
1607          * Create dest receiver in MessageContext (we don't want it in
1608          * transaction context, because that may get deleted if portal
1609          * contains VACUUM).
1610          */
1611         receiver = CreateDestReceiver(dest, portal);
1612
1613         /*
1614          * Ensure we are in a transaction command (this should normally be the
1615          * case already due to prior BIND).
1616          */
1617         start_xact_command();
1618
1619         /*
1620          * If we are in aborted transaction state, the only portals we can
1621          * actually run are those containing COMMIT or ROLLBACK commands.
1622          */
1623         if (IsAbortedTransactionBlockState())
1624         {
1625                 if (!is_trans_exit)
1626                         ereport(ERROR,
1627                                         (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
1628                                          errmsg("current transaction is aborted, "
1629                                          "commands ignored until end of transaction block")));
1630         }
1631
1632         /* Check for cancel signal before we start execution */
1633         CHECK_FOR_INTERRUPTS();
1634
1635         /*
1636          * Okay to run the portal.
1637          */
1638         if (max_rows <= 0)
1639                 max_rows = FETCH_ALL;
1640
1641         completed = PortalRun(portal,
1642                                                   max_rows,
1643                                                   receiver,
1644                                                   receiver,
1645                                                   completionTag);
1646
1647         (*receiver->rDestroy) (receiver);
1648
1649         if (completed)
1650         {
1651                 if (is_trans_stmt)
1652                 {
1653                         /*
1654                          * If this was a transaction control statement, commit it.      We
1655                          * will start a new xact command for the next command (if
1656                          * any).
1657                          */
1658                         finish_xact_command();
1659                 }
1660                 else
1661                 {
1662                         /*
1663                          * We need a CommandCounterIncrement after every query, except
1664                          * those that start or end a transaction block.
1665                          */
1666                         CommandCounterIncrement();
1667                 }
1668
1669                 /* Send appropriate CommandComplete to client */
1670                 EndCommand(completionTag, dest);
1671         }
1672         else
1673         {
1674                 /* Portal run not complete, so send PortalSuspended */
1675                 if (whereToSendOutput == Remote)
1676                         pq_putemptymessage('s');
1677         }
1678
1679         debug_query_string = NULL;
1680 }
1681
1682 /*
1683  * exec_describe_statement_message
1684  *
1685  * Process a "Describe" message for a prepared statement
1686  */
1687 static void
1688 exec_describe_statement_message(const char *stmt_name)
1689 {
1690         PreparedStatement *pstmt;
1691         TupleDesc       tupdesc;
1692         ListCell   *l;
1693         StringInfoData buf;
1694
1695         /* Find prepared statement */
1696         if (stmt_name[0] != '\0')
1697                 pstmt = FetchPreparedStatement(stmt_name, true);
1698         else
1699         {
1700                 /* special-case the unnamed statement */
1701                 pstmt = unnamed_stmt_pstmt;
1702                 if (!pstmt)
1703                         ereport(ERROR,
1704                                         (errcode(ERRCODE_UNDEFINED_PSTATEMENT),
1705                                    errmsg("unnamed prepared statement does not exist")));
1706         }
1707
1708         if (whereToSendOutput != Remote)
1709                 return;                                 /* can't actually do anything... */
1710
1711         /*
1712          * First describe the parameters...
1713          */
1714         pq_beginmessage(&buf, 't'); /* parameter description message type */
1715         pq_sendint(&buf, list_length(pstmt->argtype_list), 2);
1716
1717         foreach(l, pstmt->argtype_list)
1718         {
1719                 Oid                     ptype = lfirst_oid(l);
1720
1721                 pq_sendint(&buf, (int) ptype, 4);
1722         }
1723         pq_endmessage(&buf);
1724
1725         /*
1726          * Next send RowDescription or NoData to describe the result...
1727          */
1728         tupdesc = FetchPreparedStatementResultDesc(pstmt);
1729         if (tupdesc)
1730         {
1731                 List       *targetlist;
1732
1733                 if (ChoosePortalStrategy(pstmt->query_list) == PORTAL_ONE_SELECT)
1734                         targetlist = ((Query *) linitial(pstmt->query_list))->targetList;
1735                 else
1736                         targetlist = NIL;
1737                 SendRowDescriptionMessage(tupdesc, targetlist, NULL);
1738         }
1739         else
1740                 pq_putemptymessage('n');        /* NoData */
1741
1742 }
1743
1744 /*
1745  * exec_describe_portal_message
1746  *
1747  * Process a "Describe" message for a portal
1748  */
1749 static void
1750 exec_describe_portal_message(const char *portal_name)
1751 {
1752         Portal          portal;
1753
1754         portal = GetPortalByName(portal_name);
1755         if (!PortalIsValid(portal))
1756                 ereport(ERROR,
1757                                 (errcode(ERRCODE_UNDEFINED_CURSOR),
1758                                  errmsg("portal \"%s\" does not exist", portal_name)));
1759
1760         if (whereToSendOutput != Remote)
1761                 return;                                 /* can't actually do anything... */
1762
1763         if (portal->tupDesc)
1764         {
1765                 List       *targetlist;
1766
1767                 if (portal->strategy == PORTAL_ONE_SELECT)
1768                         targetlist = ((Query *) linitial(portal->parseTrees))->targetList;
1769                 else
1770                         targetlist = NIL;
1771                 SendRowDescriptionMessage(portal->tupDesc, targetlist,
1772                                                                   portal->formats);
1773         }
1774         else
1775                 pq_putemptymessage('n');        /* NoData */
1776 }
1777
1778
1779 /*
1780  * Convenience routines for starting/committing a single command.
1781  */
1782 static void
1783 start_xact_command(void)
1784 {
1785         if (!xact_started)
1786         {
1787                 ereport(DEBUG3,
1788                                 (errmsg_internal("StartTransactionCommand")));
1789                 StartTransactionCommand();
1790
1791                 /* Set statement timeout running, if any */
1792                 if (StatementTimeout > 0)
1793                         enable_sig_alarm(StatementTimeout, true);
1794
1795                 xact_started = true;
1796         }
1797 }
1798
1799 static void
1800 finish_xact_command(void)
1801 {
1802         if (xact_started)
1803         {
1804                 /* Invoke IMMEDIATE constraint triggers */
1805                 DeferredTriggerEndQuery();
1806
1807                 /* Cancel any active statement timeout before committing */
1808                 disable_sig_alarm(true);
1809
1810                 /* Now commit the command */
1811                 ereport(DEBUG3,
1812                                 (errmsg_internal("CommitTransactionCommand")));
1813
1814                 CommitTransactionCommand();
1815
1816 #ifdef MEMORY_CONTEXT_CHECKING
1817                 /* Check all memory contexts that weren't freed during commit */
1818                 /* (those that were, were checked before being deleted) */
1819                 MemoryContextCheck(TopMemoryContext);
1820 #endif
1821
1822 #ifdef SHOW_MEMORY_STATS
1823                 /* Print mem stats after each commit for leak tracking */
1824                 if (ShowStats)
1825                         MemoryContextStats(TopMemoryContext);
1826 #endif
1827
1828                 xact_started = false;
1829         }
1830 }
1831
1832
1833 /* --------------------------------
1834  *              signal handler routines used in PostgresMain()
1835  * --------------------------------
1836  */
1837
1838 /*
1839  * quickdie() occurs when signalled SIGQUIT by the postmaster.
1840  *
1841  * Some backend has bought the farm,
1842  * so we need to stop what we're doing and exit.
1843  */
1844 void
1845 quickdie(SIGNAL_ARGS)
1846 {
1847         PG_SETMASK(&BlockSig);
1848
1849         /*
1850          * Ideally this should be ereport(FATAL), but then we'd not get
1851          * control back (perhaps could fix by doing local sigsetjmp?)
1852          */
1853         ereport(WARNING,
1854                         (errcode(ERRCODE_CRASH_SHUTDOWN),
1855                 errmsg("terminating connection because of crash of another server process"),
1856            errdetail("The postmaster has commanded this server process to roll back"
1857                                  " the current transaction and exit, because another"
1858                                  " server process exited abnormally and possibly corrupted"
1859                                  " shared memory."),
1860                          errhint("In a moment you should be able to reconnect to the"
1861                                          " database and repeat your command.")));
1862
1863         /*
1864          * DO NOT proc_exit() -- we're here because shared memory may be
1865          * corrupted, so we don't want to try to clean up our transaction.
1866          * Just nail the windows shut and get out of town.
1867          *
1868          * Note we do exit(1) not exit(0).      This is to force the postmaster into
1869          * a system reset cycle if some idiot DBA sends a manual SIGQUIT to a
1870          * random backend.      This is necessary precisely because we don't clean
1871          * up our shared memory state.
1872          */
1873         exit(1);
1874 }
1875
1876 /*
1877  * Shutdown signal from postmaster: abort transaction and exit
1878  * at soonest convenient time
1879  */
1880 void
1881 die(SIGNAL_ARGS)
1882 {
1883         int                     save_errno = errno;
1884
1885         /* Don't joggle the elbow of proc_exit */
1886         if (!proc_exit_inprogress)
1887         {
1888                 InterruptPending = true;
1889                 ProcDiePending = true;
1890
1891                 /*
1892                  * If it's safe to interrupt, and we're waiting for input or a
1893                  * lock, service the interrupt immediately
1894                  */
1895                 if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
1896                         CritSectionCount == 0)
1897                 {
1898                         /* bump holdoff count to make ProcessInterrupts() a no-op */
1899                         /* until we are done getting ready for it */
1900                         InterruptHoldoffCount++;
1901                         DisableNotifyInterrupt();
1902                         DisableCatchupInterrupt();
1903                         /* Make sure CheckDeadLock won't run while shutting down... */
1904                         LockWaitCancel();
1905                         InterruptHoldoffCount--;
1906                         ProcessInterrupts();
1907                 }
1908         }
1909
1910         errno = save_errno;
1911 }
1912
1913 /*
1914  * Timeout or shutdown signal from postmaster during client authentication.
1915  * Simply exit(0).
1916  *
1917  * XXX: possible future improvement: try to send a message indicating
1918  * why we are disconnecting.  Problem is to be sure we don't block while
1919  * doing so, nor mess up the authentication message exchange.
1920  */
1921 void
1922 authdie(SIGNAL_ARGS)
1923 {
1924         exit(0);
1925 }
1926
1927 /*
1928  * Query-cancel signal from postmaster: abort current transaction
1929  * at soonest convenient time
1930  */
1931 static void
1932 StatementCancelHandler(SIGNAL_ARGS)
1933 {
1934         int                     save_errno = errno;
1935
1936         /*
1937          * Don't joggle the elbow of proc_exit, nor an already-in-progress
1938          * abort
1939          */
1940         if (!proc_exit_inprogress && !InError)
1941         {
1942                 InterruptPending = true;
1943                 QueryCancelPending = true;
1944
1945                 /*
1946                  * If it's safe to interrupt, and we're waiting for a lock,
1947                  * service the interrupt immediately.  No point in interrupting if
1948                  * we're waiting for input, however.
1949                  */
1950                 if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
1951                         CritSectionCount == 0)
1952                 {
1953                         /* bump holdoff count to make ProcessInterrupts() a no-op */
1954                         /* until we are done getting ready for it */
1955                         InterruptHoldoffCount++;
1956                         if (LockWaitCancel())
1957                         {
1958                                 DisableNotifyInterrupt();
1959                                 DisableCatchupInterrupt();
1960                                 InterruptHoldoffCount--;
1961                                 ProcessInterrupts();
1962                         }
1963                         else
1964                                 InterruptHoldoffCount--;
1965                 }
1966         }
1967
1968         errno = save_errno;
1969 }
1970
1971 /* signal handler for floating point exception */
1972 static void
1973 FloatExceptionHandler(SIGNAL_ARGS)
1974 {
1975         ereport(ERROR,
1976                         (errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
1977                          errmsg("floating-point exception"),
1978                    errdetail("An invalid floating-point operation was signaled. "
1979                                          "This probably means an out-of-range result or an "
1980                                          "invalid operation, such as division by zero.")));
1981 }
1982
1983 /* SIGHUP: set flag to re-read config file at next convenient time */
1984 static void
1985 SigHupHandler(SIGNAL_ARGS)
1986 {
1987         got_SIGHUP = true;
1988 }
1989
1990
1991 /*
1992  * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro
1993  *
1994  * If an interrupt condition is pending, and it's safe to service it,
1995  * then clear the flag and accept the interrupt.  Called only when
1996  * InterruptPending is true.
1997  */
1998 void
1999 ProcessInterrupts(void)
2000 {
2001         /* OK to accept interrupt now? */
2002         if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
2003                 return;
2004         InterruptPending = false;
2005         if (ProcDiePending)
2006         {
2007                 ProcDiePending = false;
2008                 QueryCancelPending = false;             /* ProcDie trumps QueryCancel */
2009                 ImmediateInterruptOK = false;   /* not idle anymore */
2010                 DisableNotifyInterrupt();
2011                 DisableCatchupInterrupt();
2012                 ereport(FATAL,
2013                                 (errcode(ERRCODE_ADMIN_SHUTDOWN),
2014                  errmsg("terminating connection due to administrator command")));
2015         }
2016         if (QueryCancelPending)
2017         {
2018                 QueryCancelPending = false;
2019                 ImmediateInterruptOK = false;   /* not idle anymore */
2020                 DisableNotifyInterrupt();
2021                 DisableCatchupInterrupt();
2022                 ereport(ERROR,
2023                                 (errcode(ERRCODE_QUERY_CANCELED),
2024                                  errmsg("canceling query due to user request")));
2025         }
2026         /* If we get here, do nothing (probably, QueryCancelPending was reset) */
2027 }
2028
2029
2030 /*
2031  * check_stack_depth: check for excessively deep recursion
2032  *
2033  * This should be called someplace in any recursive routine that might possibly
2034  * recurse deep enough to overflow the stack.  Most Unixen treat stack
2035  * overflow as an unrecoverable SIGSEGV, so we want to error out ourselves
2036  * before hitting the hardware limit.  Unfortunately we have no direct way
2037  * to detect the hardware limit, so we have to rely on the admin to set a
2038  * GUC variable for it ...
2039  */
2040 void
2041 check_stack_depth(void)
2042 {
2043         char    stack_top_loc;
2044         int             stack_depth;
2045
2046         /*
2047          * Compute distance from PostgresMain's local variables to my own
2048          *
2049          * Note: in theory stack_depth should be ptrdiff_t or some such, but
2050          * since the whole point of this code is to bound the value to something
2051          * much less than integer-sized, int should work fine.
2052          */
2053         stack_depth = (int) (stack_base_ptr - &stack_top_loc);
2054         /*
2055          * Take abs value, since stacks grow up on some machines, down on others
2056          */
2057         if (stack_depth < 0)
2058                 stack_depth = -stack_depth;
2059         /*
2060          * Trouble?
2061          *
2062          * The test on stack_base_ptr prevents us from erroring out if called
2063          * during process setup or in a non-backend process.  Logically it should
2064          * be done first, but putting it here avoids wasting cycles during normal
2065          * cases.
2066          */
2067         if (stack_depth > max_stack_depth_bytes &&
2068                 stack_base_ptr != NULL)
2069         {
2070                 ereport(ERROR,
2071                                 (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
2072                                  errmsg("stack depth limit exceeded"),
2073                                  errhint("Increase the configuration parameter \"max_stack_depth\".")));
2074         }
2075 }
2076
2077 /* GUC assign hook to update max_stack_depth_bytes from max_stack_depth */
2078 bool
2079 assign_max_stack_depth(int newval, bool doit, GucSource source)
2080 {
2081         /* Range check was already handled by guc.c */
2082         if (doit)
2083                 max_stack_depth_bytes = newval * 1024;
2084         return true;
2085 }
2086
2087
2088 static void
2089 usage(const char *progname)
2090 {
2091         printf(gettext("%s is the PostgreSQL stand-alone backend.  It is not\nintended to be used by normal users.\n\n"), progname);
2092
2093         printf(gettext("Usage:\n  %s [OPTION]... [DBNAME]\n\n"), progname);
2094         printf(gettext("Options:\n"));
2095 #ifdef USE_ASSERT_CHECKING
2096         printf(gettext("  -A 1|0          enable/disable run-time assert checking\n"));
2097 #endif
2098         printf(gettext("  -B NBUFFERS     number of shared buffers\n"));
2099         printf(gettext("  -c NAME=VALUE   set run-time parameter\n"));
2100         printf(gettext("  -d 0-5          debugging level (0 is off)\n"));
2101         printf(gettext("  -D DATADIR      database directory\n"));
2102         printf(gettext("  -e              use European date input format (DMY)\n"));
2103         printf(gettext("  -E              echo query before execution\n"));
2104         printf(gettext("  -F              turn fsync off\n"));
2105         printf(gettext("  -N              do not use newline as interactive query delimiter\n"));
2106         printf(gettext("  -o FILENAME     send stdout and stderr to given file\n"));
2107         printf(gettext("  -P              disable system indexes\n"));
2108         printf(gettext("  -s              show statistics after each query\n"));
2109         printf(gettext("  -S WORK-MEM     set amount of memory for sorts (in kbytes)\n"));
2110         printf(gettext("  --describe-config  describe configuration parameters, then exit\n"));
2111         printf(gettext("  --help          show this help, then exit\n"));
2112         printf(gettext("  --version       output version information, then exit\n"));
2113         printf(gettext("\nDeveloper options:\n"));
2114         printf(gettext("  -f s|i|n|m|h    forbid use of some plan types\n"));
2115         printf(gettext("  -i              do not execute queries\n"));
2116         printf(gettext("  -O              allow system table structure changes\n"));
2117         printf(gettext("  -t pa|pl|ex     show timings after each query\n"));
2118         printf(gettext("  -W NUM          wait NUM seconds to allow attach from a debugger\n"));
2119         printf(gettext("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
2120 }
2121
2122
2123
2124 /* ----------------------------------------------------------------
2125  * PostgresMain
2126  *         postgres main loop -- all backends, interactive or otherwise start here
2127  *
2128  * argc/argv are the command line arguments to be used.  (When being forked
2129  * by the postmaster, these are not the original argv array of the process.)
2130  * username is the (possibly authenticated) PostgreSQL user name to be used
2131  * for the session.
2132  * ----------------------------------------------------------------
2133  */
2134 int
2135 PostgresMain(int argc, char *argv[], const char *username)
2136 {
2137         int                     flag;
2138         const char *dbname = NULL;
2139         char       *potential_DataDir = NULL;
2140         bool            secure;
2141         int                     errs = 0;
2142         int                     debug_flag = 0;
2143         GucContext      ctx,
2144                                 debug_context;
2145         GucSource       gucsource;
2146         char       *tmp;
2147         int                     firstchar;
2148         char            stack_base;
2149         StringInfoData  input_message;
2150         volatile bool send_rfq = true;
2151
2152         /*
2153          * Catch standard options before doing much else.  This even works on
2154          * systems without getopt_long.
2155          */
2156         if (!IsUnderPostmaster && argc > 1)
2157         {
2158                 if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
2159                 {
2160                         usage(argv[0]);
2161                         exit(0);
2162                 }
2163                 if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
2164                 {
2165                         puts(PG_VERSIONSTR);
2166                         exit(0);
2167                 }
2168         }
2169
2170         /*
2171          * initialize globals (already done if under postmaster, but not if
2172          * standalone; cheap enough to do over)
2173          */
2174         MyProcPid = getpid();
2175
2176         /*
2177          * Fire up essential subsystems: error and memory management
2178          *
2179          * If we are running under the postmaster, this is done already.
2180          */
2181         if (!IsUnderPostmaster)
2182                 MemoryContextInit();
2183
2184         set_ps_display("startup");
2185
2186         SetProcessingMode(InitProcessing);
2187
2188         /* Set up reference point for stack depth checking */
2189         stack_base_ptr = &stack_base;
2190
2191         /* Compute paths, if we didn't inherit them from postmaster */
2192         if (my_exec_path[0] == '\0')
2193         {
2194                 if (find_my_exec(argv[0], my_exec_path) < 0)
2195                         elog(FATAL, "%s: could not locate my own executable path",
2196                                  argv[0]);
2197         }
2198
2199         if (pkglib_path[0] == '\0')
2200                 get_pkglib_path(my_exec_path, pkglib_path);
2201
2202         /*
2203          * Set default values for command-line options.
2204          */
2205         EchoQuery = false;
2206
2207         if (!IsUnderPostmaster)
2208         {
2209                 InitializeGUCOptions();
2210                 potential_DataDir = getenv("PGDATA");
2211         }
2212
2213         /* ----------------
2214          *      parse command line arguments
2215          *
2216          *      There are now two styles of command line layout for the backend:
2217          *
2218          *      For interactive use (not started from postmaster) the format is
2219          *              postgres [switches] [databasename]
2220          *      If the databasename is omitted it is taken to be the user name.
2221          *
2222          *      When started from the postmaster, the format is
2223          *              postgres [secure switches] -p databasename [insecure switches]
2224          *      Switches appearing after -p came from the client (via "options"
2225          *      field of connection request).  For security reasons we restrict
2226          *      what these switches can do.
2227          * ----------------
2228          */
2229
2230         /* all options are allowed until '-p' */
2231         secure = true;
2232         ctx = debug_context = PGC_POSTMASTER;
2233         gucsource = PGC_S_ARGV;         /* initial switches came from command line */
2234
2235         while ((flag = getopt(argc, argv, "A:B:c:D:d:Eef:FiNOPo:p:S:st:v:W:-:")) != -1)
2236                 switch (flag)
2237                 {
2238                         case 'A':
2239 #ifdef USE_ASSERT_CHECKING
2240                                 SetConfigOption("debug_assertions", optarg, ctx, gucsource);
2241 #else
2242                                 ereport(WARNING,
2243                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2244                                                  errmsg("assert checking is not compiled in")));
2245 #endif
2246                                 break;
2247
2248                         case 'B':
2249
2250                                 /*
2251                                  * specify the size of buffer pool
2252                                  */
2253                                 SetConfigOption("shared_buffers", optarg, ctx, gucsource);
2254                                 break;
2255
2256                         case 'D':                       /* PGDATA directory */
2257                                 if (secure)
2258                                         potential_DataDir = optarg;
2259                                 break;
2260
2261                         case 'd':                       /* debug level */
2262                                 {
2263                                         /*
2264                                          * Client option can't decrease debug level. We have
2265                                          * to do the test here because we group priv and
2266                                          * client set GUC calls below, after we know the final
2267                                          * debug value.
2268                                          */
2269                                         if (ctx != PGC_BACKEND || atoi(optarg) > debug_flag)
2270                                         {
2271                                                 debug_flag = atoi(optarg);
2272                                                 debug_context = ctx;    /* save context for use
2273                                                                                                  * below */
2274                                                 /* Set server debugging level. */
2275                                                 if (debug_flag != 0)
2276                                                 {
2277                                                         char       *debugstr = palloc(strlen("debug") + strlen(optarg) + 1);
2278
2279                                                         sprintf(debugstr, "debug%s", optarg);
2280                                                         SetConfigOption("log_min_messages", debugstr, ctx, gucsource);
2281                                                         pfree(debugstr);
2282
2283                                                 }
2284                                                 else
2285
2286                                                         /*
2287                                                          * -d0 allows user to prevent postmaster debug
2288                                                          * from propagating to backend.  It would be
2289                                                          * nice to set it to the postgresql.conf value
2290                                                          * here.
2291                                                          */
2292                                                         SetConfigOption("log_min_messages", "notice",
2293                                                                                         ctx, gucsource);
2294                                         }
2295                                 }
2296                                 break;
2297
2298                         case 'E':
2299
2300                                 /*
2301                                  * E - echo the query the user entered
2302                                  */
2303                                 EchoQuery = true;
2304                                 break;
2305
2306                         case 'e':
2307
2308                                 /*
2309                                  * Use European date input format (DMY)
2310                                  */
2311                                 SetConfigOption("datestyle", "euro", ctx, gucsource);
2312                                 break;
2313
2314                         case 'F':
2315
2316                                 /*
2317                                  * turn off fsync
2318                                  */
2319                                 SetConfigOption("fsync", "false", ctx, gucsource);
2320                                 break;
2321
2322                         case 'f':
2323
2324                                 /*
2325                                  * f - forbid generation of certain plans
2326                                  */
2327                                 tmp = NULL;
2328                                 switch (optarg[0])
2329                                 {
2330                                         case 's':       /* seqscan */
2331                                                 tmp = "enable_seqscan";
2332                                                 break;
2333                                         case 'i':       /* indexscan */
2334                                                 tmp = "enable_indexscan";
2335                                                 break;
2336                                         case 't':       /* tidscan */
2337                                                 tmp = "enable_tidscan";
2338                                                 break;
2339                                         case 'n':       /* nestloop */
2340                                                 tmp = "enable_nestloop";
2341                                                 break;
2342                                         case 'm':       /* mergejoin */
2343                                                 tmp = "enable_mergejoin";
2344                                                 break;
2345                                         case 'h':       /* hashjoin */
2346                                                 tmp = "enable_hashjoin";
2347                                                 break;
2348                                         default:
2349                                                 errs++;
2350                                 }
2351                                 if (tmp)
2352                                         SetConfigOption(tmp, "false", ctx, gucsource);
2353                                 break;
2354
2355                         case 'N':
2356
2357                                 /*
2358                                  * N - Don't use newline as a query delimiter
2359                                  */
2360                                 UseNewLine = 0;
2361                                 break;
2362
2363                         case 'O':
2364
2365                                 /*
2366                                  * allow system table structure modifications
2367                                  */
2368                                 if (secure)             /* XXX safe to allow from client??? */
2369                                         allowSystemTableMods = true;
2370                                 break;
2371
2372                         case 'P':
2373
2374                                 /*
2375                                  * ignore system indexes
2376                                  *
2377                                  * As of PG 7.4 this is safe to allow from the client,
2378                                  * since it only disables reading the system indexes,
2379                                  * not writing them.  Worst case consequence is slowness.
2380                                  */
2381                                 IgnoreSystemIndexes(true);
2382                                 break;
2383
2384                         case 'o':
2385
2386                                 /*
2387                                  * o - send output (stdout and stderr) to the given file
2388                                  */
2389                                 if (secure)
2390                                         StrNCpy(OutputFileName, optarg, MAXPGPATH);
2391                                 break;
2392
2393                         case 'p':
2394                                 /*
2395                                  * p - special flag passed if backend was forked by a
2396                                  * postmaster.
2397                                  */
2398                                 if (secure)
2399                                 {
2400                                         dbname = strdup(optarg);
2401
2402                                         secure = false;         /* subsequent switches are NOT
2403                                                                                  * secure */
2404                                         ctx = PGC_BACKEND;
2405                                         gucsource = PGC_S_CLIENT;
2406                                 }
2407                                 break;
2408
2409                         case 'S':
2410
2411                                 /*
2412                                  * S - amount of sort memory to use in 1k bytes
2413                                  */
2414                                 SetConfigOption("work_mem", optarg, ctx, gucsource);
2415                                 break;
2416
2417                         case 's':
2418
2419                                 /*
2420                                  * s - report usage statistics (timings) after each query
2421                                  */
2422                                 SetConfigOption("log_statement_stats", "true", ctx, gucsource);
2423                                 break;
2424
2425                         case 't':
2426                                 /* ---------------
2427                                  *      tell postgres to report usage statistics (timings) for
2428                                  *      each query
2429                                  *
2430                                  *      -tpa[rser] = print stats for parser time of each query
2431                                  *      -tpl[anner] = print stats for planner time of each query
2432                                  *      -te[xecutor] = print stats for executor time of each query
2433                                  *      caution: -s can not be used together with -t.
2434                                  * ----------------
2435                                  */
2436                                 tmp = NULL;
2437                                 switch (optarg[0])
2438                                 {
2439                                         case 'p':
2440                                                 if (optarg[1] == 'a')
2441                                                         tmp = "log_parser_stats";
2442                                                 else if (optarg[1] == 'l')
2443                                                         tmp = "log_planner_stats";
2444                                                 else
2445                                                         errs++;
2446                                                 break;
2447                                         case 'e':
2448                                                 tmp = "log_executor_stats";
2449                                                 break;
2450                                         default:
2451                                                 errs++;
2452                                                 break;
2453                                 }
2454                                 if (tmp)
2455                                         SetConfigOption(tmp, "true", ctx, gucsource);
2456                                 break;
2457
2458                         case 'v':
2459                                 if (secure)
2460                                         FrontendProtocol = (ProtocolVersion) atoi(optarg);
2461                                 break;
2462
2463                         case 'W':
2464
2465                                 /*
2466                                  * wait N seconds to allow attach from a debugger
2467                                  */
2468                                 pg_usleep(atoi(optarg)*1000000L);
2469                                 break;
2470
2471                         case 'c':
2472                         case '-':
2473                                 {
2474                                         char       *name,
2475                                                            *value;
2476
2477                                         ParseLongOption(optarg, &name, &value);
2478                                         if (!value)
2479                                         {
2480                                                 if (flag == '-')
2481                                                         ereport(ERROR,
2482                                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2483                                                                          errmsg("--%s requires a value",
2484                                                                                         optarg)));
2485                                                 else
2486                                                         ereport(ERROR,
2487                                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2488                                                                          errmsg("-c %s requires a value",
2489                                                                                         optarg)));
2490                                         }
2491
2492                                         SetConfigOption(name, value, ctx, gucsource);
2493                                         free(name);
2494                                         if (value)
2495                                                 free(value);
2496                                         break;
2497                                 }
2498
2499                         default:
2500                                 errs++;
2501                                 break;
2502                 }
2503
2504
2505         /*
2506          * -d is not the same as setting log_min_messages because it enables
2507          * other output options.
2508          */
2509         if (debug_flag >= 1)
2510         {
2511                 SetConfigOption("log_connections", "true", debug_context, gucsource);
2512                 SetConfigOption("log_disconnections", "true", debug_context, gucsource);
2513         }
2514         if (debug_flag >= 2)
2515                 SetConfigOption("log_statement", "all", debug_context, gucsource);
2516         if (debug_flag >= 3)
2517                 SetConfigOption("debug_print_parse", "true", debug_context, gucsource);
2518         if (debug_flag >= 4)
2519                 SetConfigOption("debug_print_plan", "true", debug_context, gucsource);
2520         if (debug_flag >= 5)
2521                 SetConfigOption("debug_print_rewritten", "true", debug_context, gucsource);
2522
2523         /*
2524          * Process any additional GUC variable settings passed in startup
2525          * packet.
2526          */
2527         if (MyProcPort != NULL)
2528         {
2529                 ListCell   *gucopts = list_head(MyProcPort->guc_options);
2530
2531                 while (gucopts)
2532                 {
2533                         char *name;
2534                         char *value;
2535
2536                         name = lfirst(gucopts);
2537                         gucopts = lnext(gucopts);
2538
2539                         value = lfirst(gucopts);
2540                         gucopts = lnext(gucopts);
2541
2542                         SetConfigOption(name, value, PGC_BACKEND, PGC_S_CLIENT);
2543                 }
2544
2545                 /*
2546                  * set up handler to log session end.
2547                  */
2548                 if (IsUnderPostmaster && Log_disconnections)
2549                         on_proc_exit(log_disconnections,0);
2550         }
2551
2552         if (!IsUnderPostmaster)
2553         {
2554                 if (!potential_DataDir)
2555                 {
2556                         fprintf(stderr,
2557                                         gettext("%s does not know where to find the database system data.\n"
2558                                                         "You must specify the directory that contains the database system\n"
2559                                                         "either by specifying the -D invocation option or by setting the\n"
2560                                                         "PGDATA environment variable.\n"),
2561                                         argv[0]);
2562                         proc_exit(1);
2563                 }
2564                 SetDataDir(potential_DataDir);
2565         }
2566         Assert(DataDir);
2567
2568         /* Acquire configuration parameters, unless inherited from postmaster */
2569         if (!IsUnderPostmaster)
2570         {
2571                 ProcessConfigFile(PGC_POSTMASTER);
2572
2573                 /* If timezone is not set, determine what the OS uses */
2574                 pg_timezone_initialize();
2575         }
2576
2577         /*
2578          * Set up signal handlers and masks.
2579          *
2580          * Note that postmaster blocked all signals before forking child process,
2581          * so there is no race condition whereby we might receive a signal
2582          * before we have set up the handler.
2583          *
2584          * Also note: it's best not to use any signals that are SIG_IGNored in
2585          * the postmaster.      If such a signal arrives before we are able to
2586          * change the handler to non-SIG_IGN, it'll get dropped.  Instead,
2587          * make a dummy handler in the postmaster to reserve the signal. (Of
2588          * course, this isn't an issue for signals that are locally generated,
2589          * such as SIGALRM and SIGPIPE.)
2590          */
2591         pqsignal(SIGHUP, SigHupHandler);        /* set flag to read config file */
2592         pqsignal(SIGINT, StatementCancelHandler);       /* cancel current query */
2593         pqsignal(SIGTERM, die);         /* cancel current query and exit */
2594         pqsignal(SIGQUIT, quickdie);    /* hard crash time */
2595         pqsignal(SIGALRM, handle_sig_alarm);            /* timeout conditions */
2596
2597         /*
2598          * Ignore failure to write to frontend. Note: if frontend closes
2599          * connection, we will notice it and exit cleanly when control next
2600          * returns to outer loop.  This seems safer than forcing exit in the
2601          * midst of output during who-knows-what operation...
2602          */
2603         pqsignal(SIGPIPE, SIG_IGN);
2604         pqsignal(SIGUSR1, CatchupInterruptHandler);
2605         pqsignal(SIGUSR2, NotifyInterruptHandler);
2606         pqsignal(SIGFPE, FloatExceptionHandler);
2607
2608         /*
2609          * Reset some signals that are accepted by postmaster but not by
2610          * backend
2611          */
2612         pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
2613                                                                  * platforms */
2614
2615         pqinitmask();
2616
2617         /* We allow SIGQUIT (quickdie) at all times */
2618 #ifdef HAVE_SIGPROCMASK
2619         sigdelset(&BlockSig, SIGQUIT);
2620 #else
2621         BlockSig &= ~(sigmask(SIGQUIT));
2622 #endif
2623
2624         PG_SETMASK(&BlockSig);          /* block everything except SIGQUIT */
2625
2626
2627         if (IsUnderPostmaster)
2628         {
2629                 /* noninteractive case: nothing should be left after switches */
2630                 if (errs || argc != optind || dbname == NULL)
2631                 {
2632                         ereport(FATAL,
2633                                         (errcode(ERRCODE_SYNTAX_ERROR),
2634                                          errmsg("invalid command-line arguments for server process"),
2635                                          errhint("Try \"%s --help\" for more information.", argv[0])));
2636                 }
2637
2638                 XLOGPathInit();
2639
2640                 BaseInit();
2641         }
2642         else
2643         {
2644                 /* interactive case: database name can be last arg on command line */
2645                 if (errs || argc - optind > 1)
2646                 {
2647                         ereport(FATAL,
2648                                         (errcode(ERRCODE_SYNTAX_ERROR),
2649                                          errmsg("%s: invalid command-line arguments",
2650                                                         argv[0]),
2651                                          errhint("Try \"%s --help\" for more information.", argv[0])));
2652                 }
2653                 else if (argc - optind == 1)
2654                         dbname = argv[optind];
2655                 else if ((dbname = username) == NULL)
2656                 {
2657                         ereport(FATAL,
2658                                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2659                                          errmsg("%s: no database nor user name specified",
2660                                                         argv[0])));
2661                 }
2662
2663                 /*
2664                  * Validate we have been given a reasonable-looking DataDir (if
2665                  * under postmaster, assume postmaster did this already).
2666                  */
2667                 ValidatePgVersion(DataDir);
2668
2669                 /*
2670                  * Create lockfile for data directory.
2671                  */
2672                 CreateDataDirLockFile(DataDir, false);
2673
2674                 XLOGPathInit();
2675                 BaseInit();
2676
2677                 /*
2678                  * Start up xlog for standalone backend, and register to have it
2679                  * closed down at exit.
2680                  */
2681                 StartupXLOG();
2682                 on_shmem_exit(ShutdownXLOG, 0);
2683
2684                 /*
2685                  * Read any existing FSM cache file, and register to write one out
2686                  * at exit.
2687                  */
2688                 LoadFreeSpaceMap();
2689                 on_shmem_exit(DumpFreeSpaceMap, 0);
2690         }
2691
2692         /*
2693          * General initialization.
2694          *
2695          * NOTE: if you are tempted to add code in this vicinity, consider
2696          * putting it inside InitPostgres() instead.  In particular, anything
2697          * that involves database access should be there, not here.
2698          */
2699         ereport(DEBUG3,
2700                         (errmsg_internal("InitPostgres")));
2701         InitPostgres(dbname, username);
2702
2703         SetProcessingMode(NormalProcessing);
2704
2705         /*
2706          * Send this backend's cancellation info to the frontend.
2707          */
2708         if (whereToSendOutput == Remote &&
2709                 PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
2710         {
2711                 StringInfoData buf;
2712
2713                 pq_beginmessage(&buf, 'K');
2714                 pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
2715                 pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
2716                 pq_endmessage(&buf);
2717                 /* Need not flush since ReadyForQuery will do it. */
2718         }
2719
2720         /* Welcome banner for standalone case */
2721         if (whereToSendOutput == Debug)
2722                 printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION);
2723
2724         /*
2725          * Create the memory context we will use in the main loop.
2726          *
2727          * MessageContext is reset once per iteration of the main loop, ie, upon
2728          * completion of processing of each command message from the client.
2729          */
2730         MessageContext = AllocSetContextCreate(TopMemoryContext,
2731                                                                                    "MessageContext",
2732                                                                                    ALLOCSET_DEFAULT_MINSIZE,
2733                                                                                    ALLOCSET_DEFAULT_INITSIZE,
2734                                                                                    ALLOCSET_DEFAULT_MAXSIZE);
2735
2736         /* ----------
2737          * Tell the statistics collector that we're alive and
2738          * to which database we belong.
2739          * ----------
2740          */
2741         pgstat_bestart();
2742
2743         /*
2744          * POSTGRES main processing loop begins here
2745          *
2746          * If an exception is encountered, processing resumes here so we abort
2747          * the current transaction and start a new one.
2748          */
2749
2750         if (sigsetjmp(Warn_restart, 1) != 0)
2751         {
2752                 /*
2753                  * NOTE: if you are tempted to add more code in this if-block,
2754                  * consider the probability that it should be in
2755                  * AbortTransaction() instead.
2756                  *
2757                  * Make sure we're not interrupted while cleaning up.  Also forget
2758                  * any pending QueryCancel request, since we're aborting anyway.
2759                  * Force InterruptHoldoffCount to a known state in case we
2760                  * ereport'd from inside a holdoff section.
2761                  */
2762                 ImmediateInterruptOK = false;
2763                 QueryCancelPending = false;
2764                 InterruptHoldoffCount = 1;
2765                 CritSectionCount = 0;   /* should be unnecessary, but... */
2766                 disable_sig_alarm(true);
2767                 QueryCancelPending = false;             /* again in case timeout occurred */
2768                 DisableNotifyInterrupt();
2769                 DisableCatchupInterrupt();
2770                 debug_query_string = NULL;
2771
2772                 /*
2773                  * Make sure we are in a valid memory context during recovery.
2774                  *
2775                  * We use ErrorContext in hopes that it will have some free space
2776                  * even if we're otherwise up against it...
2777                  */
2778                 MemoryContextSwitchTo(ErrorContext);
2779
2780                 /* Do the recovery */
2781                 ereport(DEBUG2,
2782                                 (errmsg_internal("AbortCurrentTransaction")));
2783                 AbortCurrentTransaction();
2784
2785                 /*
2786                  * Now return to normal top-level context and clear ErrorContext
2787                  * for next time.
2788                  */
2789                 MemoryContextSwitchTo(TopMemoryContext);
2790                 MemoryContextResetAndDeleteChildren(ErrorContext);
2791                 ActivePortal = NULL;
2792                 PortalContext = NULL;
2793                 QueryContext = NULL;
2794
2795                 /*
2796                  * Clear flag to indicate that we got out of error recovery mode
2797                  * successfully.  (Flag was set in elog.c before longjmp().)
2798                  */
2799                 InError = false;
2800                 xact_started = false;
2801
2802                 /*
2803                  * Clear flag that causes accounting for cost based vacuum.
2804                  */
2805                 VacuumCostActive = false;
2806
2807                 /*
2808                  * If we were handling an extended-query-protocol message,
2809                  * initiate skip till next Sync.  This also causes us not to issue
2810                  * ReadyForQuery (until we get Sync).
2811                  */
2812                 if (doing_extended_query_message)
2813                         ignore_till_sync = true;
2814
2815                 /*
2816                  * Exit interrupt holdoff section we implicitly established above.
2817                  */
2818                 RESUME_INTERRUPTS();
2819         }
2820
2821         Warn_restart_ready = true;      /* we can now handle ereport(ERROR) */
2822
2823         PG_SETMASK(&UnBlockSig);
2824
2825         if (!ignore_till_sync)
2826                 send_rfq = true;                /* initially, or after error */
2827
2828         /*
2829          * Non-error queries loop here.
2830          */
2831
2832         for (;;)
2833         {
2834                 /*
2835                  * At top of loop, reset extended-query-message flag, so that any
2836                  * errors encountered in "idle" state don't provoke skip.
2837                  */
2838                 doing_extended_query_message = false;
2839
2840                 /*
2841                  * Release storage left over from prior query cycle, and create a
2842                  * new query input buffer in the cleared MessageContext.
2843                  */
2844                 MemoryContextSwitchTo(MessageContext);
2845                 MemoryContextResetAndDeleteChildren(MessageContext);
2846
2847                 initStringInfo(&input_message);
2848
2849                 /*
2850                  * (1) If we've reached idle state, tell the frontend we're ready
2851                  * for a new query.
2852                  *
2853                  * Note: this includes fflush()'ing the last of the prior output.
2854                  *
2855                  * This is also a good time to send collected statistics to the
2856                  * collector, and to update the PS stats display.  We avoid doing
2857                  * those every time through the message loop because it'd slow down
2858                  * processing of batched messages.
2859                  */
2860                 if (send_rfq)
2861                 {
2862                         pgstat_report_tabstat();
2863
2864                         if (IsTransactionOrTransactionBlock())
2865                         {
2866                                 set_ps_display("idle in transaction");
2867                                 pgstat_report_activity("<IDLE> in transaction");
2868                         }
2869                         else
2870                         {
2871                                 set_ps_display("idle");
2872                                 pgstat_report_activity("<IDLE>");
2873                         }
2874
2875                         ReadyForQuery(whereToSendOutput);
2876                         send_rfq = false;
2877                 }
2878
2879                 /*
2880                  * (2) deal with pending asynchronous NOTIFY from other backends,
2881                  * and enable async.c's signal handler to execute NOTIFY directly.
2882                  * Then set up other stuff needed before blocking for input.
2883                  */
2884                 QueryCancelPending = false;             /* forget any earlier CANCEL
2885                                                                                  * signal */
2886
2887                 EnableNotifyInterrupt();
2888                 EnableCatchupInterrupt();
2889
2890                 /* Allow "die" interrupt to be processed while waiting */
2891                 ImmediateInterruptOK = true;
2892                 /* and don't forget to detect one that already arrived */
2893                 QueryCancelPending = false;
2894                 CHECK_FOR_INTERRUPTS();
2895
2896                 /*
2897                  * (3) read a command (loop blocks here)
2898                  */
2899                  if (!in_fatal_exit)
2900                         firstchar = ReadCommand(&input_message);
2901                 else
2902                         firstchar = EOF;
2903
2904                 /*
2905                  * (4) disable async signal conditions again.
2906                  */
2907                 ImmediateInterruptOK = false;
2908                 QueryCancelPending = false;             /* forget any CANCEL signal */
2909
2910                 DisableNotifyInterrupt();
2911                 DisableCatchupInterrupt();
2912
2913                 /*
2914                  * (5) check for any other interesting events that happened while
2915                  * we slept.
2916                  */
2917                 if (got_SIGHUP)
2918                 {
2919                         got_SIGHUP = false;
2920                         ProcessConfigFile(PGC_SIGHUP);
2921                 }
2922
2923                 /*
2924                  * (6) process the command.  But ignore it if we're skipping till
2925                  * Sync.
2926                  */
2927                 if (ignore_till_sync && firstchar != EOF)
2928                         continue;
2929
2930                 switch (firstchar)
2931                 {
2932                         case 'Q':                       /* simple query */
2933                                 {
2934                                         const char *query_string;
2935
2936                                         query_string = pq_getmsgstring(&input_message);
2937                                         pq_getmsgend(&input_message);
2938
2939                                         exec_simple_query(query_string);
2940
2941                                         send_rfq = true;
2942                                 }
2943                                 break;
2944
2945                         case 'P':                       /* parse */
2946                                 {
2947                                         const char *stmt_name;
2948                                         const char *query_string;
2949                                         int                     numParams;
2950                                         Oid                *paramTypes = NULL;
2951
2952                                         stmt_name = pq_getmsgstring(&input_message);
2953                                         query_string = pq_getmsgstring(&input_message);
2954                                         numParams = pq_getmsgint(&input_message, 2);
2955                                         if (numParams > 0)
2956                                         {
2957                                                 int                     i;
2958
2959                                                 paramTypes = (Oid *) palloc(numParams * sizeof(Oid));
2960                                                 for (i = 0; i < numParams; i++)
2961                                                         paramTypes[i] = pq_getmsgint(&input_message, 4);
2962                                         }
2963                                         pq_getmsgend(&input_message);
2964
2965                                         exec_parse_message(query_string, stmt_name,
2966                                                                            paramTypes, numParams);
2967                                 }
2968                                 break;
2969
2970                         case 'B':                       /* bind */
2971
2972                                 /*
2973                                  * this message is complex enough that it seems best to
2974                                  * put the field extraction out-of-line
2975                                  */
2976                                 exec_bind_message(&input_message);
2977                                 break;
2978
2979                         case 'E':                       /* execute */
2980                                 {
2981                                         const char *portal_name;
2982                                         int                     max_rows;
2983
2984                                         portal_name = pq_getmsgstring(&input_message);
2985                                         max_rows = pq_getmsgint(&input_message, 4);
2986                                         pq_getmsgend(&input_message);
2987
2988                                         exec_execute_message(portal_name, max_rows);
2989                                 }
2990                                 break;
2991
2992                         case 'F':                       /* fastpath function call */
2993                                 /* Tell the collector what we're doing */
2994                                 pgstat_report_activity("<FASTPATH> function call");
2995
2996                                 /* start an xact for this function invocation */
2997                                 start_xact_command();
2998
2999                                 /* switch back to message context */
3000                                 MemoryContextSwitchTo(MessageContext);
3001
3002                                 if (HandleFunctionRequest(&input_message) == EOF)
3003                                 {
3004                                         /* lost frontend connection during F message input */
3005
3006                                         /*
3007                                          * Reset whereToSendOutput to prevent ereport from
3008                                          * attempting to send any more messages to client.
3009                                          */
3010                                         if (whereToSendOutput == Remote)
3011                                                 whereToSendOutput = None;
3012
3013                                         proc_exit(0);
3014                                 }
3015
3016                                 /* commit the function-invocation transaction */
3017                                 finish_xact_command();
3018
3019                                 send_rfq = true;
3020                                 break;
3021
3022                         case 'C':                       /* close */
3023                                 {
3024                                         int                     close_type;
3025                                         const char *close_target;
3026
3027                                         close_type = pq_getmsgbyte(&input_message);
3028                                         close_target = pq_getmsgstring(&input_message);
3029                                         pq_getmsgend(&input_message);
3030
3031                                         switch (close_type)
3032                                         {
3033                                                 case 'S':
3034                                                         if (close_target[0] != '\0')
3035                                                                 DropPreparedStatement(close_target, false);
3036                                                         else
3037                                                         {
3038                                                                 /* special-case the unnamed statement */
3039                                                                 unnamed_stmt_pstmt = NULL;
3040                                                                 if (unnamed_stmt_context)
3041                                                                 {
3042                                                                         DropDependentPortals(unnamed_stmt_context);
3043                                                                         MemoryContextDelete(unnamed_stmt_context);
3044                                                                 }
3045                                                                 unnamed_stmt_context = NULL;
3046                                                         }
3047                                                         break;
3048                                                 case 'P':
3049                                                         {
3050                                                                 Portal          portal;
3051
3052                                                                 portal = GetPortalByName(close_target);
3053                                                                 if (PortalIsValid(portal))
3054                                                                         PortalDrop(portal, false);
3055                                                         }
3056                                                         break;
3057                                                 default:
3058                                                         ereport(ERROR,
3059                                                                         (errcode(ERRCODE_PROTOCOL_VIOLATION),
3060                                                            errmsg("invalid CLOSE message subtype %d",
3061                                                                           close_type)));
3062                                                         break;
3063                                         }
3064
3065                                         if (whereToSendOutput == Remote)
3066                                                 pq_putemptymessage('3');                /* CloseComplete */
3067                                 }
3068                                 break;
3069
3070                         case 'D':                       /* describe */
3071                                 {
3072                                         int                     describe_type;
3073                                         const char *describe_target;
3074
3075                                         describe_type = pq_getmsgbyte(&input_message);
3076                                         describe_target = pq_getmsgstring(&input_message);
3077                                         pq_getmsgend(&input_message);
3078
3079                                         switch (describe_type)
3080                                         {
3081                                                 case 'S':
3082                                                         exec_describe_statement_message(describe_target);
3083                                                         break;
3084                                                 case 'P':
3085                                                         exec_describe_portal_message(describe_target);
3086                                                         break;
3087                                                 default:
3088                                                         ereport(ERROR,
3089                                                                         (errcode(ERRCODE_PROTOCOL_VIOLATION),
3090                                                         errmsg("invalid DESCRIBE message subtype %d",
3091                                                                    describe_type)));
3092                                                         break;
3093                                         }
3094                                 }
3095                                 break;
3096
3097                         case 'H':                       /* flush */
3098                                 pq_getmsgend(&input_message);
3099                                 if (whereToSendOutput == Remote)
3100                                         pq_flush();
3101                                 break;
3102
3103                         case 'S':                       /* sync */
3104                                 pq_getmsgend(&input_message);
3105                                 finish_xact_command();
3106                                 send_rfq = true;
3107                                 break;
3108
3109                                 /*
3110                                  * 'X' means that the frontend is closing down the socket.
3111                                  * EOF means unexpected loss of frontend connection.
3112                                  * Either way, perform normal shutdown.
3113                                  */
3114                         case 'X':
3115                         case EOF:
3116
3117                                 /*
3118                                  * Reset whereToSendOutput to prevent ereport from
3119                                  * attempting to send any more messages to client.
3120                                  */
3121                                 if (whereToSendOutput == Remote)
3122                                         whereToSendOutput = None;
3123
3124                                 /*
3125                                  * NOTE: if you are tempted to add more code here, DON'T!
3126                                  * Whatever you had in mind to do should be set up as an
3127                                  * on_proc_exit or on_shmem_exit callback, instead.
3128                                  * Otherwise it will fail to be called during other
3129                                  * backend-shutdown scenarios.
3130                                  */
3131                                 proc_exit(!in_fatal_exit ? 0 : proc_exit_inprogress ||
3132                                                                                                 !IsUnderPostmaster);
3133
3134                         case 'd':                       /* copy data */
3135                         case 'c':                       /* copy done */
3136                         case 'f':                       /* copy fail */
3137
3138                                 /*
3139                                  * Accept but ignore these messages, per protocol spec; we
3140                                  * probably got here because a COPY failed, and the
3141                                  * frontend is still sending data.
3142                                  */
3143                                 break;
3144
3145                         default:
3146                                 ereport(FATAL,
3147                                                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
3148                                                  errmsg("invalid frontend message type %d",
3149                                                                 firstchar)));
3150                 }
3151         }                                                       /* end of input-reading loop */
3152
3153         /* can't get here because the above loop never exits */
3154         Assert(false);
3155
3156         return 1;                                       /* keep compiler quiet */
3157 }
3158
3159 #ifndef HAVE_GETRUSAGE
3160 #include "rusagestub.h"
3161 #else
3162 #include <sys/resource.h>
3163 #endif   /* HAVE_GETRUSAGE */
3164
3165 static struct rusage Save_r;
3166 static struct timeval Save_t;
3167
3168 void
3169 ResetUsage(void)
3170 {
3171         getrusage(RUSAGE_SELF, &Save_r);
3172         gettimeofday(&Save_t, NULL);
3173         ResetBufferUsage();
3174         /* ResetTupleCount(); */
3175 }
3176
3177 void
3178 ShowUsage(const char *title)
3179 {
3180         StringInfoData str;
3181         struct timeval user,
3182                                 sys;
3183         struct timeval elapse_t;
3184         struct rusage r;
3185         char       *bufusage;
3186
3187         getrusage(RUSAGE_SELF, &r);
3188         gettimeofday(&elapse_t, NULL);
3189         memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
3190         memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
3191         if (elapse_t.tv_usec < Save_t.tv_usec)
3192         {
3193                 elapse_t.tv_sec--;
3194                 elapse_t.tv_usec += 1000000;
3195         }
3196         if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
3197         {
3198                 r.ru_utime.tv_sec--;
3199                 r.ru_utime.tv_usec += 1000000;
3200         }
3201         if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
3202         {
3203                 r.ru_stime.tv_sec--;
3204                 r.ru_stime.tv_usec += 1000000;
3205         }
3206
3207         /*
3208          * the only stats we don't show here are for memory usage -- i can't
3209          * figure out how to interpret the relevant fields in the rusage
3210          * struct, and they change names across o/s platforms, anyway. if you
3211          * can figure out what the entries mean, you can somehow extract
3212          * resident set size, shared text size, and unshared data and stack
3213          * sizes.
3214          */
3215         initStringInfo(&str);
3216
3217         appendStringInfo(&str, "! system usage stats:\n");
3218         appendStringInfo(&str,
3219                         "!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
3220                                          (long) (elapse_t.tv_sec - Save_t.tv_sec),
3221                                          (long) (elapse_t.tv_usec - Save_t.tv_usec),
3222                                          (long) (r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec),
3223                                    (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
3224                                          (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
3225                                   (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec));
3226         appendStringInfo(&str,
3227                                          "!\t[%ld.%06ld user %ld.%06ld sys total]\n",
3228                                          (long) user.tv_sec,
3229                                          (long) user.tv_usec,
3230                                          (long) sys.tv_sec,
3231                                          (long) sys.tv_usec);
3232 /* BeOS has rusage but only has some fields, and not these... */
3233 #if defined(HAVE_GETRUSAGE)
3234         appendStringInfo(&str,
3235                                          "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
3236                                          r.ru_inblock - Save_r.ru_inblock,
3237         /* they only drink coffee at dec */
3238                                          r.ru_oublock - Save_r.ru_oublock,
3239                                          r.ru_inblock, r.ru_oublock);
3240         appendStringInfo(&str,
3241                   "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
3242                                          r.ru_majflt - Save_r.ru_majflt,
3243                                          r.ru_minflt - Save_r.ru_minflt,
3244                                          r.ru_majflt, r.ru_minflt,
3245                                          r.ru_nswap - Save_r.ru_nswap,
3246                                          r.ru_nswap);
3247         appendStringInfo(&str,
3248          "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
3249                                          r.ru_nsignals - Save_r.ru_nsignals,
3250                                          r.ru_nsignals,
3251                                          r.ru_msgrcv - Save_r.ru_msgrcv,
3252                                          r.ru_msgsnd - Save_r.ru_msgsnd,
3253                                          r.ru_msgrcv, r.ru_msgsnd);
3254         appendStringInfo(&str,
3255                  "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
3256                                          r.ru_nvcsw - Save_r.ru_nvcsw,
3257                                          r.ru_nivcsw - Save_r.ru_nivcsw,
3258                                          r.ru_nvcsw, r.ru_nivcsw);
3259 #endif   /* HAVE_GETRUSAGE */
3260
3261         bufusage = ShowBufferUsage();
3262         appendStringInfo(&str, "! buffer usage stats:\n%s", bufusage);
3263         pfree(bufusage);
3264
3265         /* remove trailing newline */
3266         if (str.data[str.len - 1] == '\n')
3267                 str.data[--str.len] = '\0';
3268
3269         ereport(LOG,
3270                         (errmsg_internal("%s", title),
3271                          errdetail("%s", str.data)));
3272
3273         pfree(str.data);
3274 }
3275
3276 /*
3277  * on_proc_exit handler to log end of session
3278  */
3279 static void
3280 log_disconnections(int code, Datum arg)
3281 {
3282         Port *port = MyProcPort;
3283         struct timeval end;
3284         int  hours, minutes, seconds;
3285
3286         char session_time[20];
3287         char uname[6+NAMEDATALEN];
3288         char dbname[10+NAMEDATALEN];
3289         char remote_host[7 + NI_MAXHOST];
3290         char remote_port[7 + NI_MAXSERV];
3291
3292         snprintf(uname, sizeof(uname)," user=%s",port->user_name);
3293         snprintf(dbname, sizeof(dbname)," database=%s",port->database_name);
3294         snprintf(remote_host,sizeof(remote_host)," host=%s",
3295                          port->remote_host);
3296         snprintf(remote_port,sizeof(remote_port)," port=%s",port->remote_port);
3297
3298
3299         gettimeofday(&end,NULL);
3300
3301         if (end.tv_usec < port->session_start.tv_usec)
3302         {
3303                 end.tv_sec--;
3304                 end.tv_usec += 1000000;
3305         }
3306         end.tv_sec -= port->session_start.tv_sec;
3307         end.tv_usec -= port->session_start.tv_usec;
3308
3309         hours = end.tv_sec / 3600;
3310         end.tv_sec %= 3600;
3311         minutes = end.tv_sec / 60;
3312         seconds = end.tv_sec % 60;
3313
3314         /* if time has gone backwards for some reason say so, or print time */
3315
3316         if (end.tv_sec < 0)
3317                 snprintf(session_time,sizeof(session_time),"negative!");
3318         else
3319                 /* for stricter accuracy here we could round - this is close enough */
3320                 snprintf(session_time, sizeof(session_time),
3321                          "%d:%02d:%02d.%02d",
3322                          hours, minutes, seconds, (int) (end.tv_usec/10000));
3323
3324         ereport(
3325                 LOG,
3326                 (errmsg("disconnection: session time: %s%s%s%s%s",
3327                                 session_time,uname,dbname,remote_host,remote_port)));
3328
3329 }