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