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