LCOV - code coverage report
Current view: top level - src/backend/tcop - postgres.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 1165 1556 74.9 %
Date: 2025-04-24 12:15:10 Functions: 51 58 87.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * postgres.c
       4             :  *    POSTGRES C Backend Interface
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/tcop/postgres.c
      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 <fcntl.h>
      23             : #include <limits.h>
      24             : #include <signal.h>
      25             : #include <unistd.h>
      26             : #include <sys/resource.h>
      27             : #include <sys/socket.h>
      28             : #include <sys/time.h>
      29             : 
      30             : #ifdef USE_VALGRIND
      31             : #include <valgrind/valgrind.h>
      32             : #endif
      33             : 
      34             : #include "access/parallel.h"
      35             : #include "access/printtup.h"
      36             : #include "access/xact.h"
      37             : #include "catalog/pg_type.h"
      38             : #include "commands/async.h"
      39             : #include "commands/event_trigger.h"
      40             : #include "commands/prepare.h"
      41             : #include "common/pg_prng.h"
      42             : #include "jit/jit.h"
      43             : #include "libpq/libpq.h"
      44             : #include "libpq/pqformat.h"
      45             : #include "libpq/pqsignal.h"
      46             : #include "mb/pg_wchar.h"
      47             : #include "mb/stringinfo_mb.h"
      48             : #include "miscadmin.h"
      49             : #include "nodes/print.h"
      50             : #include "optimizer/optimizer.h"
      51             : #include "parser/analyze.h"
      52             : #include "parser/parser.h"
      53             : #include "pg_getopt.h"
      54             : #include "pg_trace.h"
      55             : #include "pgstat.h"
      56             : #include "postmaster/interrupt.h"
      57             : #include "postmaster/postmaster.h"
      58             : #include "replication/logicallauncher.h"
      59             : #include "replication/logicalworker.h"
      60             : #include "replication/slot.h"
      61             : #include "replication/walsender.h"
      62             : #include "rewrite/rewriteHandler.h"
      63             : #include "storage/bufmgr.h"
      64             : #include "storage/ipc.h"
      65             : #include "storage/pmsignal.h"
      66             : #include "storage/proc.h"
      67             : #include "storage/procsignal.h"
      68             : #include "storage/sinval.h"
      69             : #include "tcop/backend_startup.h"
      70             : #include "tcop/fastpath.h"
      71             : #include "tcop/pquery.h"
      72             : #include "tcop/tcopprot.h"
      73             : #include "tcop/utility.h"
      74             : #include "utils/guc_hooks.h"
      75             : #include "utils/injection_point.h"
      76             : #include "utils/lsyscache.h"
      77             : #include "utils/memutils.h"
      78             : #include "utils/ps_status.h"
      79             : #include "utils/snapmgr.h"
      80             : #include "utils/timeout.h"
      81             : #include "utils/timestamp.h"
      82             : #include "utils/varlena.h"
      83             : 
      84             : /* ----------------
      85             :  *      global variables
      86             :  * ----------------
      87             :  */
      88             : const char *debug_query_string; /* client-supplied query string */
      89             : 
      90             : /* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
      91             : CommandDest whereToSendOutput = DestDebug;
      92             : 
      93             : /* flag for logging end of session */
      94             : bool        Log_disconnections = false;
      95             : 
      96             : int         log_statement = LOGSTMT_NONE;
      97             : 
      98             : /* wait N seconds to allow attach from a debugger */
      99             : int         PostAuthDelay = 0;
     100             : 
     101             : /* Time between checks that the client is still connected. */
     102             : int         client_connection_check_interval = 0;
     103             : 
     104             : /* flags for non-system relation kinds to restrict use */
     105             : int         restrict_nonsystem_relation_kind;
     106             : 
     107             : /* ----------------
     108             :  *      private typedefs etc
     109             :  * ----------------
     110             :  */
     111             : 
     112             : /* type of argument for bind_param_error_callback */
     113             : typedef struct BindParamCbData
     114             : {
     115             :     const char *portalName;
     116             :     int         paramno;        /* zero-based param number, or -1 initially */
     117             :     const char *paramval;       /* textual input string, if available */
     118             : } BindParamCbData;
     119             : 
     120             : /* ----------------
     121             :  *      private variables
     122             :  * ----------------
     123             :  */
     124             : 
     125             : /*
     126             :  * Flag to keep track of whether we have started a transaction.
     127             :  * For extended query protocol this has to be remembered across messages.
     128             :  */
     129             : static bool xact_started = false;
     130             : 
     131             : /*
     132             :  * Flag to indicate that we are doing the outer loop's read-from-client,
     133             :  * as opposed to any random read from client that might happen within
     134             :  * commands like COPY FROM STDIN.
     135             :  */
     136             : static bool DoingCommandRead = false;
     137             : 
     138             : /*
     139             :  * Flags to implement skip-till-Sync-after-error behavior for messages of
     140             :  * the extended query protocol.
     141             :  */
     142             : static bool doing_extended_query_message = false;
     143             : static bool ignore_till_sync = false;
     144             : 
     145             : /*
     146             :  * If an unnamed prepared statement exists, it's stored here.
     147             :  * We keep it separate from the hashtable kept by commands/prepare.c
     148             :  * in order to reduce overhead for short-lived queries.
     149             :  */
     150             : static CachedPlanSource *unnamed_stmt_psrc = NULL;
     151             : 
     152             : /* assorted command-line switches */
     153             : static const char *userDoption = NULL;  /* -D switch */
     154             : static bool EchoQuery = false;  /* -E switch */
     155             : static bool UseSemiNewlineNewline = false;  /* -j switch */
     156             : 
     157             : /* whether or not, and why, we were canceled by conflict with recovery */
     158             : static volatile sig_atomic_t RecoveryConflictPending = false;
     159             : static volatile sig_atomic_t RecoveryConflictPendingReasons[NUM_PROCSIGNALS];
     160             : 
     161             : /* reused buffer to pass to SendRowDescriptionMessage() */
     162             : static MemoryContext row_description_context = NULL;
     163             : static StringInfoData row_description_buf;
     164             : 
     165             : /* ----------------------------------------------------------------
     166             :  *      decls for routines only used in this file
     167             :  * ----------------------------------------------------------------
     168             :  */
     169             : static int  InteractiveBackend(StringInfo inBuf);
     170             : static int  interactive_getc(void);
     171             : static int  SocketBackend(StringInfo inBuf);
     172             : static int  ReadCommand(StringInfo inBuf);
     173             : static void forbidden_in_wal_sender(char firstchar);
     174             : static bool check_log_statement(List *stmt_list);
     175             : static int  errdetail_execute(List *raw_parsetree_list);
     176             : static int  errdetail_params(ParamListInfo params);
     177             : static int  errdetail_abort(void);
     178             : static void bind_param_error_callback(void *arg);
     179             : static void start_xact_command(void);
     180             : static void finish_xact_command(void);
     181             : static bool IsTransactionExitStmt(Node *parsetree);
     182             : static bool IsTransactionExitStmtList(List *pstmts);
     183             : static bool IsTransactionStmtList(List *pstmts);
     184             : static void drop_unnamed_stmt(void);
     185             : static void log_disconnections(int code, Datum arg);
     186             : static void enable_statement_timeout(void);
     187             : static void disable_statement_timeout(void);
     188             : 
     189             : 
     190             : /* ----------------------------------------------------------------
     191             :  *      infrastructure for valgrind debugging
     192             :  * ----------------------------------------------------------------
     193             :  */
     194             : #ifdef USE_VALGRIND
     195             : /* This variable should be set at the top of the main loop. */
     196             : static unsigned int old_valgrind_error_count;
     197             : 
     198             : /*
     199             :  * If Valgrind detected any errors since old_valgrind_error_count was updated,
     200             :  * report the current query as the cause.  This should be called at the end
     201             :  * of message processing.
     202             :  */
     203             : static void
     204             : valgrind_report_error_query(const char *query)
     205             : {
     206             :     unsigned int valgrind_error_count = VALGRIND_COUNT_ERRORS;
     207             : 
     208             :     if (unlikely(valgrind_error_count != old_valgrind_error_count) &&
     209             :         query != NULL)
     210             :         VALGRIND_PRINTF("Valgrind detected %u error(s) during execution of \"%s\"\n",
     211             :                         valgrind_error_count - old_valgrind_error_count,
     212             :                         query);
     213             : }
     214             : 
     215             : #else                           /* !USE_VALGRIND */
     216             : #define valgrind_report_error_query(query) ((void) 0)
     217             : #endif                          /* USE_VALGRIND */
     218             : 
     219             : 
     220             : /* ----------------------------------------------------------------
     221             :  *      routines to obtain user input
     222             :  * ----------------------------------------------------------------
     223             :  */
     224             : 
     225             : /* ----------------
     226             :  *  InteractiveBackend() is called for user interactive connections
     227             :  *
     228             :  *  the string entered by the user is placed in its parameter inBuf,
     229             :  *  and we act like a Q message was received.
     230             :  *
     231             :  *  EOF is returned if end-of-file input is seen; time to shut down.
     232             :  * ----------------
     233             :  */
     234             : 
     235             : static int
     236       67980 : InteractiveBackend(StringInfo inBuf)
     237             : {
     238             :     int         c;              /* character read from getc() */
     239             : 
     240             :     /*
     241             :      * display a prompt and obtain input from the user
     242             :      */
     243       67980 :     printf("backend> ");
     244       67980 :     fflush(stdout);
     245             : 
     246       67980 :     resetStringInfo(inBuf);
     247             : 
     248             :     /*
     249             :      * Read characters until EOF or the appropriate delimiter is seen.
     250             :      */
     251    23677584 :     while ((c = interactive_getc()) != EOF)
     252             :     {
     253    23677472 :         if (c == '\n')
     254             :         {
     255      637132 :             if (UseSemiNewlineNewline)
     256             :             {
     257             :                 /*
     258             :                  * In -j mode, semicolon followed by two newlines ends the
     259             :                  * command; otherwise treat newline as regular character.
     260             :                  */
     261      637132 :                 if (inBuf->len > 1 &&
     262      629518 :                     inBuf->data[inBuf->len - 1] == '\n' &&
     263      100862 :                     inBuf->data[inBuf->len - 2] == ';')
     264             :                 {
     265             :                     /* might as well drop the second newline */
     266       67868 :                     break;
     267             :                 }
     268             :             }
     269             :             else
     270             :             {
     271             :                 /*
     272             :                  * In plain mode, newline ends the command unless preceded by
     273             :                  * backslash.
     274             :                  */
     275           0 :                 if (inBuf->len > 0 &&
     276           0 :                     inBuf->data[inBuf->len - 1] == '\\')
     277             :                 {
     278             :                     /* discard backslash from inBuf */
     279           0 :                     inBuf->data[--inBuf->len] = '\0';
     280             :                     /* discard newline too */
     281           0 :                     continue;
     282             :                 }
     283             :                 else
     284             :                 {
     285             :                     /* keep the newline character, but end the command */
     286           0 :                     appendStringInfoChar(inBuf, '\n');
     287           0 :                     break;
     288             :                 }
     289             :             }
     290             :         }
     291             : 
     292             :         /* Not newline, or newline treated as regular character */
     293    23609604 :         appendStringInfoChar(inBuf, (char) c);
     294             :     }
     295             : 
     296             :     /* No input before EOF signal means time to quit. */
     297       67980 :     if (c == EOF && inBuf->len == 0)
     298         112 :         return EOF;
     299             : 
     300             :     /*
     301             :      * otherwise we have a user query so process it.
     302             :      */
     303             : 
     304             :     /* Add '\0' to make it look the same as message case. */
     305       67868 :     appendStringInfoChar(inBuf, (char) '\0');
     306             : 
     307             :     /*
     308             :      * if the query echo flag was given, print the query..
     309             :      */
     310       67868 :     if (EchoQuery)
     311           0 :         printf("statement: %s\n", inBuf->data);
     312       67868 :     fflush(stdout);
     313             : 
     314       67868 :     return PqMsg_Query;
     315             : }
     316             : 
     317             : /*
     318             :  * interactive_getc -- collect one character from stdin
     319             :  *
     320             :  * Even though we are not reading from a "client" process, we still want to
     321             :  * respond to signals, particularly SIGTERM/SIGQUIT.
     322             :  */
     323             : static int
     324    23677584 : interactive_getc(void)
     325             : {
     326             :     int         c;
     327             : 
     328             :     /*
     329             :      * This will not process catchup interrupts or notifications while
     330             :      * reading. But those can't really be relevant for a standalone backend
     331             :      * anyway. To properly handle SIGTERM there's a hack in die() that
     332             :      * directly processes interrupts at this stage...
     333             :      */
     334    23677584 :     CHECK_FOR_INTERRUPTS();
     335             : 
     336    23677584 :     c = getc(stdin);
     337             : 
     338    23677584 :     ProcessClientReadInterrupt(false);
     339             : 
     340    23677584 :     return c;
     341             : }
     342             : 
     343             : /* ----------------
     344             :  *  SocketBackend()     Is called for frontend-backend connections
     345             :  *
     346             :  *  Returns the message type code, and loads message body data into inBuf.
     347             :  *
     348             :  *  EOF is returned if the connection is lost.
     349             :  * ----------------
     350             :  */
     351             : static int
     352      745830 : SocketBackend(StringInfo inBuf)
     353             : {
     354             :     int         qtype;
     355             :     int         maxmsglen;
     356             : 
     357             :     /*
     358             :      * Get message type code from the frontend.
     359             :      */
     360      745830 :     HOLD_CANCEL_INTERRUPTS();
     361      745830 :     pq_startmsgread();
     362      745830 :     qtype = pq_getbyte();
     363             : 
     364      745744 :     if (qtype == EOF)           /* frontend disconnected */
     365             :     {
     366          90 :         if (IsTransactionState())
     367           8 :             ereport(COMMERROR,
     368             :                     (errcode(ERRCODE_CONNECTION_FAILURE),
     369             :                      errmsg("unexpected EOF on client connection with an open transaction")));
     370             :         else
     371             :         {
     372             :             /*
     373             :              * Can't send DEBUG log messages to client at this point. Since
     374             :              * we're disconnecting right away, we don't need to restore
     375             :              * whereToSendOutput.
     376             :              */
     377          82 :             whereToSendOutput = DestNone;
     378          82 :             ereport(DEBUG1,
     379             :                     (errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST),
     380             :                      errmsg_internal("unexpected EOF on client connection")));
     381             :         }
     382          90 :         return qtype;
     383             :     }
     384             : 
     385             :     /*
     386             :      * Validate message type code before trying to read body; if we have lost
     387             :      * sync, better to say "command unknown" than to run out of memory because
     388             :      * we used garbage as a length word.  We can also select a type-dependent
     389             :      * limit on what a sane length word could be.  (The limit could be chosen
     390             :      * more granularly, but it's not clear it's worth fussing over.)
     391             :      *
     392             :      * This also gives us a place to set the doing_extended_query_message flag
     393             :      * as soon as possible.
     394             :      */
     395      745654 :     switch (qtype)
     396             :     {
     397      618072 :         case PqMsg_Query:
     398      618072 :             maxmsglen = PQ_LARGE_MESSAGE_LIMIT;
     399      618072 :             doing_extended_query_message = false;
     400      618072 :             break;
     401             : 
     402        2208 :         case PqMsg_FunctionCall:
     403        2208 :             maxmsglen = PQ_LARGE_MESSAGE_LIMIT;
     404        2208 :             doing_extended_query_message = false;
     405        2208 :             break;
     406             : 
     407       24068 :         case PqMsg_Terminate:
     408       24068 :             maxmsglen = PQ_SMALL_MESSAGE_LIMIT;
     409       24068 :             doing_extended_query_message = false;
     410       24068 :             ignore_till_sync = false;
     411       24068 :             break;
     412             : 
     413       33454 :         case PqMsg_Bind:
     414             :         case PqMsg_Parse:
     415       33454 :             maxmsglen = PQ_LARGE_MESSAGE_LIMIT;
     416       33454 :             doing_extended_query_message = true;
     417       33454 :             break;
     418             : 
     419       44728 :         case PqMsg_Close:
     420             :         case PqMsg_Describe:
     421             :         case PqMsg_Execute:
     422             :         case PqMsg_Flush:
     423       44728 :             maxmsglen = PQ_SMALL_MESSAGE_LIMIT;
     424       44728 :             doing_extended_query_message = true;
     425       44728 :             break;
     426             : 
     427       22888 :         case PqMsg_Sync:
     428       22888 :             maxmsglen = PQ_SMALL_MESSAGE_LIMIT;
     429             :             /* stop any active skip-till-Sync */
     430       22888 :             ignore_till_sync = false;
     431             :             /* mark not-extended, so that a new error doesn't begin skip */
     432       22888 :             doing_extended_query_message = false;
     433       22888 :             break;
     434             : 
     435          32 :         case PqMsg_CopyData:
     436          32 :             maxmsglen = PQ_LARGE_MESSAGE_LIMIT;
     437          32 :             doing_extended_query_message = false;
     438          32 :             break;
     439             : 
     440         204 :         case PqMsg_CopyDone:
     441             :         case PqMsg_CopyFail:
     442         204 :             maxmsglen = PQ_SMALL_MESSAGE_LIMIT;
     443         204 :             doing_extended_query_message = false;
     444         204 :             break;
     445             : 
     446           0 :         default:
     447             : 
     448             :             /*
     449             :              * Otherwise we got garbage from the frontend.  We treat this as
     450             :              * fatal because we have probably lost message boundary sync, and
     451             :              * there's no good way to recover.
     452             :              */
     453           0 :             ereport(FATAL,
     454             :                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
     455             :                      errmsg("invalid frontend message type %d", qtype)));
     456             :             maxmsglen = 0;      /* keep compiler quiet */
     457             :             break;
     458             :     }
     459             : 
     460             :     /*
     461             :      * In protocol version 3, all frontend messages have a length word next
     462             :      * after the type code; we can read the message contents independently of
     463             :      * the type.
     464             :      */
     465      745654 :     if (pq_getmessage(inBuf, maxmsglen))
     466           0 :         return EOF;             /* suitable message already logged */
     467      745654 :     RESUME_CANCEL_INTERRUPTS();
     468             : 
     469      745654 :     return qtype;
     470             : }
     471             : 
     472             : /* ----------------
     473             :  *      ReadCommand reads a command from either the frontend or
     474             :  *      standard input, places it in inBuf, and returns the
     475             :  *      message type code (first byte of the message).
     476             :  *      EOF is returned if end of file.
     477             :  * ----------------
     478             :  */
     479             : static int
     480      813810 : ReadCommand(StringInfo inBuf)
     481             : {
     482             :     int         result;
     483             : 
     484      813810 :     if (whereToSendOutput == DestRemote)
     485      745830 :         result = SocketBackend(inBuf);
     486             :     else
     487       67980 :         result = InteractiveBackend(inBuf);
     488      813724 :     return result;
     489             : }
     490             : 
     491             : /*
     492             :  * ProcessClientReadInterrupt() - Process interrupts specific to client reads
     493             :  *
     494             :  * This is called just before and after low-level reads.
     495             :  * 'blocked' is true if no data was available to read and we plan to retry,
     496             :  * false if about to read or done reading.
     497             :  *
     498             :  * Must preserve errno!
     499             :  */
     500             : void
     501    30213552 : ProcessClientReadInterrupt(bool blocked)
     502             : {
     503    30213552 :     int         save_errno = errno;
     504             : 
     505    30213552 :     if (DoingCommandRead)
     506             :     {
     507             :         /* Check for general interrupts that arrived before/while reading */
     508    25033820 :         CHECK_FOR_INTERRUPTS();
     509             : 
     510             :         /* Process sinval catchup interrupts, if any */
     511    25033734 :         if (catchupInterruptPending)
     512         732 :             ProcessCatchupInterrupt();
     513             : 
     514             :         /* Process notify interrupts, if any */
     515    25033734 :         if (notifyInterruptPending)
     516         124 :             ProcessNotifyInterrupt(true);
     517             :     }
     518     5179732 :     else if (ProcDiePending)
     519             :     {
     520             :         /*
     521             :          * We're dying.  If there is no data available to read, then it's safe
     522             :          * (and sane) to handle that now.  If we haven't tried to read yet,
     523             :          * make sure the process latch is set, so that if there is no data
     524             :          * then we'll come back here and die.  If we're done reading, also
     525             :          * make sure the process latch is set, as we might've undesirably
     526             :          * cleared it while reading.
     527             :          */
     528           0 :         if (blocked)
     529           0 :             CHECK_FOR_INTERRUPTS();
     530             :         else
     531           0 :             SetLatch(MyLatch);
     532             :     }
     533             : 
     534    30213466 :     errno = save_errno;
     535    30213466 : }
     536             : 
     537             : /*
     538             :  * ProcessClientWriteInterrupt() - Process interrupts specific to client writes
     539             :  *
     540             :  * This is called just before and after low-level writes.
     541             :  * 'blocked' is true if no data could be written and we plan to retry,
     542             :  * false if about to write or done writing.
     543             :  *
     544             :  * Must preserve errno!
     545             :  */
     546             : void
     547     4374850 : ProcessClientWriteInterrupt(bool blocked)
     548             : {
     549     4374850 :     int         save_errno = errno;
     550             : 
     551     4374850 :     if (ProcDiePending)
     552             :     {
     553             :         /*
     554             :          * We're dying.  If it's not possible to write, then we should handle
     555             :          * that immediately, else a stuck client could indefinitely delay our
     556             :          * response to the signal.  If we haven't tried to write yet, make
     557             :          * sure the process latch is set, so that if the write would block
     558             :          * then we'll come back here and die.  If we're done writing, also
     559             :          * make sure the process latch is set, as we might've undesirably
     560             :          * cleared it while writing.
     561             :          */
     562          10 :         if (blocked)
     563             :         {
     564             :             /*
     565             :              * Don't mess with whereToSendOutput if ProcessInterrupts wouldn't
     566             :              * service ProcDiePending.
     567             :              */
     568           0 :             if (InterruptHoldoffCount == 0 && CritSectionCount == 0)
     569             :             {
     570             :                 /*
     571             :                  * We don't want to send the client the error message, as a)
     572             :                  * that would possibly block again, and b) it would likely
     573             :                  * lead to loss of protocol sync because we may have already
     574             :                  * sent a partial protocol message.
     575             :                  */
     576           0 :                 if (whereToSendOutput == DestRemote)
     577           0 :                     whereToSendOutput = DestNone;
     578             : 
     579           0 :                 CHECK_FOR_INTERRUPTS();
     580             :             }
     581             :         }
     582             :         else
     583          10 :             SetLatch(MyLatch);
     584             :     }
     585             : 
     586     4374850 :     errno = save_errno;
     587     4374850 : }
     588             : 
     589             : /*
     590             :  * Do raw parsing (only).
     591             :  *
     592             :  * A list of parsetrees (RawStmt nodes) is returned, since there might be
     593             :  * multiple commands in the given string.
     594             :  *
     595             :  * NOTE: for interactive queries, it is important to keep this routine
     596             :  * separate from the analysis & rewrite stages.  Analysis and rewriting
     597             :  * cannot be done in an aborted transaction, since they require access to
     598             :  * database tables.  So, we rely on the raw parser to determine whether
     599             :  * we've seen a COMMIT or ABORT command; when we are in abort state, other
     600             :  * commands are not processed any further than the raw parse stage.
     601             :  */
     602             : List *
     603      699372 : pg_parse_query(const char *query_string)
     604             : {
     605             :     List       *raw_parsetree_list;
     606             : 
     607             :     TRACE_POSTGRESQL_QUERY_PARSE_START(query_string);
     608             : 
     609      699372 :     if (log_parser_stats)
     610           0 :         ResetUsage();
     611             : 
     612      699372 :     raw_parsetree_list = raw_parser(query_string, RAW_PARSE_DEFAULT);
     613             : 
     614      698200 :     if (log_parser_stats)
     615           0 :         ShowUsage("PARSER STATISTICS");
     616             : 
     617             : #ifdef DEBUG_NODE_TESTS_ENABLED
     618             : 
     619             :     /* Optional debugging check: pass raw parsetrees through copyObject() */
     620      698200 :     if (Debug_copy_parse_plan_trees)
     621             :     {
     622      698200 :         List       *new_list = copyObject(raw_parsetree_list);
     623             : 
     624             :         /* This checks both copyObject() and the equal() routines... */
     625      698200 :         if (!equal(new_list, raw_parsetree_list))
     626           0 :             elog(WARNING, "copyObject() failed to produce an equal raw parse tree");
     627             :         else
     628      698200 :             raw_parsetree_list = new_list;
     629             :     }
     630             : 
     631             :     /*
     632             :      * Optional debugging check: pass raw parsetrees through
     633             :      * outfuncs/readfuncs
     634             :      */
     635      698200 :     if (Debug_write_read_parse_plan_trees)
     636             :     {
     637      698200 :         char       *str = nodeToStringWithLocations(raw_parsetree_list);
     638      698200 :         List       *new_list = stringToNodeWithLocations(str);
     639             : 
     640      698200 :         pfree(str);
     641             :         /* This checks both outfuncs/readfuncs and the equal() routines... */
     642      698200 :         if (!equal(new_list, raw_parsetree_list))
     643           0 :             elog(WARNING, "outfuncs/readfuncs failed to produce an equal raw parse tree");
     644             :         else
     645      698200 :             raw_parsetree_list = new_list;
     646             :     }
     647             : 
     648             : #endif                          /* DEBUG_NODE_TESTS_ENABLED */
     649             : 
     650             :     TRACE_POSTGRESQL_QUERY_PARSE_DONE(query_string);
     651             : 
     652      698200 :     return raw_parsetree_list;
     653             : }
     654             : 
     655             : /*
     656             :  * Given a raw parsetree (gram.y output), and optionally information about
     657             :  * types of parameter symbols ($n), perform parse analysis and rule rewriting.
     658             :  *
     659             :  * A list of Query nodes is returned, since either the analyzer or the
     660             :  * rewriter might expand one query to several.
     661             :  *
     662             :  * NOTE: for reasons mentioned above, this must be separate from raw parsing.
     663             :  */
     664             : List *
     665      769158 : pg_analyze_and_rewrite_fixedparams(RawStmt *parsetree,
     666             :                                    const char *query_string,
     667             :                                    const Oid *paramTypes,
     668             :                                    int numParams,
     669             :                                    QueryEnvironment *queryEnv)
     670             : {
     671             :     Query      *query;
     672             :     List       *querytree_list;
     673             : 
     674             :     TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
     675             : 
     676             :     /*
     677             :      * (1) Perform parse analysis.
     678             :      */
     679      769158 :     if (log_parser_stats)
     680           0 :         ResetUsage();
     681             : 
     682      769158 :     query = parse_analyze_fixedparams(parsetree, query_string, paramTypes, numParams,
     683             :                                       queryEnv);
     684             : 
     685      761582 :     if (log_parser_stats)
     686           0 :         ShowUsage("PARSE ANALYSIS STATISTICS");
     687             : 
     688             :     /*
     689             :      * (2) Rewrite the queries, as necessary
     690             :      */
     691      761582 :     querytree_list = pg_rewrite_query(query);
     692             : 
     693             :     TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
     694             : 
     695      760904 :     return querytree_list;
     696             : }
     697             : 
     698             : /*
     699             :  * Do parse analysis and rewriting.  This is the same as
     700             :  * pg_analyze_and_rewrite_fixedparams except that it's okay to deduce
     701             :  * information about $n symbol datatypes from context.
     702             :  */
     703             : List *
     704       13408 : pg_analyze_and_rewrite_varparams(RawStmt *parsetree,
     705             :                                  const char *query_string,
     706             :                                  Oid **paramTypes,
     707             :                                  int *numParams,
     708             :                                  QueryEnvironment *queryEnv)
     709             : {
     710             :     Query      *query;
     711             :     List       *querytree_list;
     712             : 
     713             :     TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
     714             : 
     715             :     /*
     716             :      * (1) Perform parse analysis.
     717             :      */
     718       13408 :     if (log_parser_stats)
     719           0 :         ResetUsage();
     720             : 
     721       13408 :     query = parse_analyze_varparams(parsetree, query_string, paramTypes, numParams,
     722             :                                     queryEnv);
     723             : 
     724             :     /*
     725             :      * Check all parameter types got determined.
     726             :      */
     727       28626 :     for (int i = 0; i < *numParams; i++)
     728             :     {
     729       15240 :         Oid         ptype = (*paramTypes)[i];
     730             : 
     731       15240 :         if (ptype == InvalidOid || ptype == UNKNOWNOID)
     732           6 :             ereport(ERROR,
     733             :                     (errcode(ERRCODE_INDETERMINATE_DATATYPE),
     734             :                      errmsg("could not determine data type of parameter $%d",
     735             :                             i + 1)));
     736             :     }
     737             : 
     738       13386 :     if (log_parser_stats)
     739           0 :         ShowUsage("PARSE ANALYSIS STATISTICS");
     740             : 
     741             :     /*
     742             :      * (2) Rewrite the queries, as necessary
     743             :      */
     744       13386 :     querytree_list = pg_rewrite_query(query);
     745             : 
     746             :     TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
     747             : 
     748       13386 :     return querytree_list;
     749             : }
     750             : 
     751             : /*
     752             :  * Do parse analysis and rewriting.  This is the same as
     753             :  * pg_analyze_and_rewrite_fixedparams except that, instead of a fixed list of
     754             :  * parameter datatypes, a parser callback is supplied that can do
     755             :  * external-parameter resolution and possibly other things.
     756             :  */
     757             : List *
     758       38406 : pg_analyze_and_rewrite_withcb(RawStmt *parsetree,
     759             :                               const char *query_string,
     760             :                               ParserSetupHook parserSetup,
     761             :                               void *parserSetupArg,
     762             :                               QueryEnvironment *queryEnv)
     763             : {
     764             :     Query      *query;
     765             :     List       *querytree_list;
     766             : 
     767             :     TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
     768             : 
     769             :     /*
     770             :      * (1) Perform parse analysis.
     771             :      */
     772       38406 :     if (log_parser_stats)
     773           0 :         ResetUsage();
     774             : 
     775       38406 :     query = parse_analyze_withcb(parsetree, query_string, parserSetup, parserSetupArg,
     776             :                                  queryEnv);
     777             : 
     778       38290 :     if (log_parser_stats)
     779           0 :         ShowUsage("PARSE ANALYSIS STATISTICS");
     780             : 
     781             :     /*
     782             :      * (2) Rewrite the queries, as necessary
     783             :      */
     784       38290 :     querytree_list = pg_rewrite_query(query);
     785             : 
     786             :     TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
     787             : 
     788       38290 :     return querytree_list;
     789             : }
     790             : 
     791             : /*
     792             :  * Perform rewriting of a query produced by parse analysis.
     793             :  *
     794             :  * Note: query must just have come from the parser, because we do not do
     795             :  * AcquireRewriteLocks() on it.
     796             :  */
     797             : List *
     798      819842 : pg_rewrite_query(Query *query)
     799             : {
     800             :     List       *querytree_list;
     801             : 
     802      819842 :     if (Debug_print_parse)
     803           0 :         elog_node_display(LOG, "parse tree", query,
     804             :                           Debug_pretty_print);
     805             : 
     806      819842 :     if (log_parser_stats)
     807           0 :         ResetUsage();
     808             : 
     809      819842 :     if (query->commandType == CMD_UTILITY)
     810             :     {
     811             :         /* don't rewrite utilities, just dump 'em into result list */
     812      397222 :         querytree_list = list_make1(query);
     813             :     }
     814             :     else
     815             :     {
     816             :         /* rewrite regular queries */
     817      422620 :         querytree_list = QueryRewrite(query);
     818             :     }
     819             : 
     820      819152 :     if (log_parser_stats)
     821           0 :         ShowUsage("REWRITER STATISTICS");
     822             : 
     823             : #ifdef DEBUG_NODE_TESTS_ENABLED
     824             : 
     825             :     /* Optional debugging check: pass querytree through copyObject() */
     826      819152 :     if (Debug_copy_parse_plan_trees)
     827             :     {
     828             :         List       *new_list;
     829             : 
     830      819152 :         new_list = copyObject(querytree_list);
     831             :         /* This checks both copyObject() and the equal() routines... */
     832      819152 :         if (!equal(new_list, querytree_list))
     833           0 :             elog(WARNING, "copyObject() failed to produce an equal rewritten parse tree");
     834             :         else
     835      819152 :             querytree_list = new_list;
     836             :     }
     837             : 
     838             :     /* Optional debugging check: pass querytree through outfuncs/readfuncs */
     839      819152 :     if (Debug_write_read_parse_plan_trees)
     840             :     {
     841      819152 :         List       *new_list = NIL;
     842             :         ListCell   *lc;
     843             : 
     844     1638946 :         foreach(lc, querytree_list)
     845             :         {
     846      819794 :             Query      *curr_query = lfirst_node(Query, lc);
     847      819794 :             char       *str = nodeToStringWithLocations(curr_query);
     848      819794 :             Query      *new_query = stringToNodeWithLocations(str);
     849             : 
     850             :             /*
     851             :              * queryId is not saved in stored rules, but we must preserve it
     852             :              * here to avoid breaking pg_stat_statements.
     853             :              */
     854      819794 :             new_query->queryId = curr_query->queryId;
     855             : 
     856      819794 :             new_list = lappend(new_list, new_query);
     857      819794 :             pfree(str);
     858             :         }
     859             : 
     860             :         /* This checks both outfuncs/readfuncs and the equal() routines... */
     861      819152 :         if (!equal(new_list, querytree_list))
     862           0 :             elog(WARNING, "outfuncs/readfuncs failed to produce an equal rewritten parse tree");
     863             :         else
     864      819152 :             querytree_list = new_list;
     865             :     }
     866             : 
     867             : #endif                          /* DEBUG_NODE_TESTS_ENABLED */
     868             : 
     869      819152 :     if (Debug_print_rewritten)
     870           0 :         elog_node_display(LOG, "rewritten parse tree", querytree_list,
     871             :                           Debug_pretty_print);
     872             : 
     873      819152 :     return querytree_list;
     874             : }
     875             : 
     876             : 
     877             : /*
     878             :  * Generate a plan for a single already-rewritten query.
     879             :  * This is a thin wrapper around planner() and takes the same parameters.
     880             :  */
     881             : PlannedStmt *
     882      461084 : pg_plan_query(Query *querytree, const char *query_string, int cursorOptions,
     883             :               ParamListInfo boundParams)
     884             : {
     885             :     PlannedStmt *plan;
     886             : 
     887             :     /* Utility commands have no plans. */
     888      461084 :     if (querytree->commandType == CMD_UTILITY)
     889           0 :         return NULL;
     890             : 
     891             :     /* Planner must have a snapshot in case it calls user-defined functions. */
     892             :     Assert(ActiveSnapshotSet());
     893             : 
     894             :     TRACE_POSTGRESQL_QUERY_PLAN_START();
     895             : 
     896      461084 :     if (log_planner_stats)
     897           0 :         ResetUsage();
     898             : 
     899             :     /* call the optimizer */
     900      461084 :     plan = planner(querytree, query_string, cursorOptions, boundParams);
     901             : 
     902      456828 :     if (log_planner_stats)
     903           0 :         ShowUsage("PLANNER STATISTICS");
     904             : 
     905             : #ifdef DEBUG_NODE_TESTS_ENABLED
     906             : 
     907             :     /* Optional debugging check: pass plan tree through copyObject() */
     908      456828 :     if (Debug_copy_parse_plan_trees)
     909             :     {
     910      456828 :         PlannedStmt *new_plan = copyObject(plan);
     911             : 
     912             :         /*
     913             :          * equal() currently does not have routines to compare Plan nodes, so
     914             :          * don't try to test equality here.  Perhaps fix someday?
     915             :          */
     916             : #ifdef NOT_USED
     917             :         /* This checks both copyObject() and the equal() routines... */
     918             :         if (!equal(new_plan, plan))
     919             :             elog(WARNING, "copyObject() failed to produce an equal plan tree");
     920             :         else
     921             : #endif
     922      456828 :             plan = new_plan;
     923             :     }
     924             : 
     925             :     /* Optional debugging check: pass plan tree through outfuncs/readfuncs */
     926      456828 :     if (Debug_write_read_parse_plan_trees)
     927             :     {
     928             :         char       *str;
     929             :         PlannedStmt *new_plan;
     930             : 
     931      456828 :         str = nodeToStringWithLocations(plan);
     932      456828 :         new_plan = stringToNodeWithLocations(str);
     933      456828 :         pfree(str);
     934             : 
     935             :         /*
     936             :          * equal() currently does not have routines to compare Plan nodes, so
     937             :          * don't try to test equality here.  Perhaps fix someday?
     938             :          */
     939             : #ifdef NOT_USED
     940             :         /* This checks both outfuncs/readfuncs and the equal() routines... */
     941             :         if (!equal(new_plan, plan))
     942             :             elog(WARNING, "outfuncs/readfuncs failed to produce an equal plan tree");
     943             :         else
     944             : #endif
     945      456828 :             plan = new_plan;
     946             :     }
     947             : 
     948             : #endif                          /* DEBUG_NODE_TESTS_ENABLED */
     949             : 
     950             :     /*
     951             :      * Print plan if debugging.
     952             :      */
     953      456828 :     if (Debug_print_plan)
     954           0 :         elog_node_display(LOG, "plan", plan, Debug_pretty_print);
     955             : 
     956             :     TRACE_POSTGRESQL_QUERY_PLAN_DONE();
     957             : 
     958      456828 :     return plan;
     959             : }
     960             : 
     961             : /*
     962             :  * Generate plans for a list of already-rewritten queries.
     963             :  *
     964             :  * For normal optimizable statements, invoke the planner.  For utility
     965             :  * statements, just make a wrapper PlannedStmt node.
     966             :  *
     967             :  * The result is a list of PlannedStmt nodes.
     968             :  */
     969             : List *
     970      827860 : pg_plan_queries(List *querytrees, const char *query_string, int cursorOptions,
     971             :                 ParamListInfo boundParams)
     972             : {
     973      827860 :     List       *stmt_list = NIL;
     974             :     ListCell   *query_list;
     975             : 
     976     1652112 :     foreach(query_list, querytrees)
     977             :     {
     978      828466 :         Query      *query = lfirst_node(Query, query_list);
     979             :         PlannedStmt *stmt;
     980             : 
     981      828466 :         if (query->commandType == CMD_UTILITY)
     982             :         {
     983             :             /* Utility commands require no planning. */
     984      397200 :             stmt = makeNode(PlannedStmt);
     985      397200 :             stmt->commandType = CMD_UTILITY;
     986      397200 :             stmt->canSetTag = query->canSetTag;
     987      397200 :             stmt->utilityStmt = query->utilityStmt;
     988      397200 :             stmt->stmt_location = query->stmt_location;
     989      397200 :             stmt->stmt_len = query->stmt_len;
     990      397200 :             stmt->queryId = query->queryId;
     991             :         }
     992             :         else
     993             :         {
     994      431266 :             stmt = pg_plan_query(query, query_string, cursorOptions,
     995             :                                  boundParams);
     996             :         }
     997             : 
     998      824252 :         stmt_list = lappend(stmt_list, stmt);
     999             :     }
    1000             : 
    1001      823646 :     return stmt_list;
    1002             : }
    1003             : 
    1004             : 
    1005             : /*
    1006             :  * exec_simple_query
    1007             :  *
    1008             :  * Execute a "simple Query" protocol message.
    1009             :  */
    1010             : static void
    1011      680296 : exec_simple_query(const char *query_string)
    1012             : {
    1013      680296 :     CommandDest dest = whereToSendOutput;
    1014             :     MemoryContext oldcontext;
    1015             :     List       *parsetree_list;
    1016             :     ListCell   *parsetree_item;
    1017      680296 :     bool        save_log_statement_stats = log_statement_stats;
    1018      680296 :     bool        was_logged = false;
    1019             :     bool        use_implicit_block;
    1020             :     char        msec_str[32];
    1021             : 
    1022             :     /*
    1023             :      * Report query to various monitoring facilities.
    1024             :      */
    1025      680296 :     debug_query_string = query_string;
    1026             : 
    1027      680296 :     pgstat_report_activity(STATE_RUNNING, query_string);
    1028             : 
    1029             :     TRACE_POSTGRESQL_QUERY_START(query_string);
    1030             : 
    1031             :     /*
    1032             :      * We use save_log_statement_stats so ShowUsage doesn't report incorrect
    1033             :      * results because ResetUsage wasn't called.
    1034             :      */
    1035      680296 :     if (save_log_statement_stats)
    1036           0 :         ResetUsage();
    1037             : 
    1038             :     /*
    1039             :      * Start up a transaction command.  All queries generated by the
    1040             :      * query_string will be in this same command block, *unless* we find a
    1041             :      * BEGIN/COMMIT/ABORT statement; we have to force a new xact command after
    1042             :      * one of those, else bad things will happen in xact.c. (Note that this
    1043             :      * will normally change current memory context.)
    1044             :      */
    1045      680296 :     start_xact_command();
    1046             : 
    1047             :     /*
    1048             :      * Zap any pre-existing unnamed statement.  (While not strictly necessary,
    1049             :      * it seems best to define simple-Query mode as if it used the unnamed
    1050             :      * statement and portal; this ensures we recover any storage used by prior
    1051             :      * unnamed operations.)
    1052             :      */
    1053      680296 :     drop_unnamed_stmt();
    1054             : 
    1055             :     /*
    1056             :      * Switch to appropriate context for constructing parsetrees.
    1057             :      */
    1058      680296 :     oldcontext = MemoryContextSwitchTo(MessageContext);
    1059             : 
    1060             :     /*
    1061             :      * Do basic parsing of the query or queries (this should be safe even if
    1062             :      * we are in aborted transaction state!)
    1063             :      */
    1064      680296 :     parsetree_list = pg_parse_query(query_string);
    1065             : 
    1066             :     /* Log immediately if dictated by log_statement */
    1067      679148 :     if (check_log_statement(parsetree_list))
    1068             :     {
    1069      258312 :         ereport(LOG,
    1070             :                 (errmsg("statement: %s", query_string),
    1071             :                  errhidestmt(true),
    1072             :                  errdetail_execute(parsetree_list)));
    1073      258312 :         was_logged = true;
    1074             :     }
    1075             : 
    1076             :     /*
    1077             :      * Switch back to transaction context to enter the loop.
    1078             :      */
    1079      679148 :     MemoryContextSwitchTo(oldcontext);
    1080             : 
    1081             :     /*
    1082             :      * For historical reasons, if multiple SQL statements are given in a
    1083             :      * single "simple Query" message, we execute them as a single transaction,
    1084             :      * unless explicit transaction control commands are included to make
    1085             :      * portions of the list be separate transactions.  To represent this
    1086             :      * behavior properly in the transaction machinery, we use an "implicit"
    1087             :      * transaction block.
    1088             :      */
    1089      679148 :     use_implicit_block = (list_length(parsetree_list) > 1);
    1090             : 
    1091             :     /*
    1092             :      * Run through the raw parsetree(s) and process each one.
    1093             :      */
    1094     1360956 :     foreach(parsetree_item, parsetree_list)
    1095             :     {
    1096      723362 :         RawStmt    *parsetree = lfirst_node(RawStmt, parsetree_item);
    1097      723362 :         bool        snapshot_set = false;
    1098             :         CommandTag  commandTag;
    1099             :         QueryCompletion qc;
    1100      723362 :         MemoryContext per_parsetree_context = NULL;
    1101             :         List       *querytree_list,
    1102             :                    *plantree_list;
    1103             :         Portal      portal;
    1104             :         DestReceiver *receiver;
    1105             :         int16       format;
    1106             :         const char *cmdtagname;
    1107             :         size_t      cmdtaglen;
    1108             : 
    1109      723362 :         pgstat_report_query_id(0, true);
    1110      723362 :         pgstat_report_plan_id(0, true);
    1111             : 
    1112             :         /*
    1113             :          * Get the command name for use in status display (it also becomes the
    1114             :          * default completion tag, down inside PortalRun).  Set ps_status and
    1115             :          * do any special start-of-SQL-command processing needed by the
    1116             :          * destination.
    1117             :          */
    1118      723362 :         commandTag = CreateCommandTag(parsetree->stmt);
    1119      723362 :         cmdtagname = GetCommandTagNameAndLen(commandTag, &cmdtaglen);
    1120             : 
    1121      723362 :         set_ps_display_with_len(cmdtagname, cmdtaglen);
    1122             : 
    1123      723362 :         BeginCommand(commandTag, dest);
    1124             : 
    1125             :         /*
    1126             :          * If we are in an aborted transaction, reject all commands except
    1127             :          * COMMIT/ABORT.  It is important that this test occur before we try
    1128             :          * to do parse analysis, rewrite, or planning, since all those phases
    1129             :          * try to do database accesses, which may fail in abort state. (It
    1130             :          * might be safe to allow some additional utility commands in this
    1131             :          * state, but not many...)
    1132             :          */
    1133      723362 :         if (IsAbortedTransactionBlockState() &&
    1134        1750 :             !IsTransactionExitStmt(parsetree->stmt))
    1135          92 :             ereport(ERROR,
    1136             :                     (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
    1137             :                      errmsg("current transaction is aborted, "
    1138             :                             "commands ignored until end of transaction block"),
    1139             :                      errdetail_abort()));
    1140             : 
    1141             :         /* Make sure we are in a transaction command */
    1142      723270 :         start_xact_command();
    1143             : 
    1144             :         /*
    1145             :          * If using an implicit transaction block, and we're not already in a
    1146             :          * transaction block, start an implicit block to force this statement
    1147             :          * to be grouped together with any following ones.  (We must do this
    1148             :          * each time through the loop; otherwise, a COMMIT/ROLLBACK in the
    1149             :          * list would cause later statements to not be grouped.)
    1150             :          */
    1151      723270 :         if (use_implicit_block)
    1152       59174 :             BeginImplicitTransactionBlock();
    1153             : 
    1154             :         /* If we got a cancel signal in parsing or prior command, quit */
    1155      723270 :         CHECK_FOR_INTERRUPTS();
    1156             : 
    1157             :         /*
    1158             :          * Set up a snapshot if parse analysis/planning will need one.
    1159             :          */
    1160      723270 :         if (analyze_requires_snapshot(parsetree))
    1161             :         {
    1162      376186 :             PushActiveSnapshot(GetTransactionSnapshot());
    1163      376186 :             snapshot_set = true;
    1164             :         }
    1165             : 
    1166             :         /*
    1167             :          * OK to analyze, rewrite, and plan this query.
    1168             :          *
    1169             :          * Switch to appropriate context for constructing query and plan trees
    1170             :          * (these can't be in the transaction context, as that will get reset
    1171             :          * when the command is COMMIT/ROLLBACK).  If we have multiple
    1172             :          * parsetrees, we use a separate context for each one, so that we can
    1173             :          * free that memory before moving on to the next one.  But for the
    1174             :          * last (or only) parsetree, just use MessageContext, which will be
    1175             :          * reset shortly after completion anyway.  In event of an error, the
    1176             :          * per_parsetree_context will be deleted when MessageContext is reset.
    1177             :          */
    1178      723270 :         if (lnext(parsetree_list, parsetree_item) != NULL)
    1179             :         {
    1180             :             per_parsetree_context =
    1181       45484 :                 AllocSetContextCreate(MessageContext,
    1182             :                                       "per-parsetree message context",
    1183             :                                       ALLOCSET_DEFAULT_SIZES);
    1184       45484 :             oldcontext = MemoryContextSwitchTo(per_parsetree_context);
    1185             :         }
    1186             :         else
    1187      677786 :             oldcontext = MemoryContextSwitchTo(MessageContext);
    1188             : 
    1189      723270 :         querytree_list = pg_analyze_and_rewrite_fixedparams(parsetree, query_string,
    1190             :                                                             NULL, 0, NULL);
    1191             : 
    1192      715062 :         plantree_list = pg_plan_queries(querytree_list, query_string,
    1193             :                                         CURSOR_OPT_PARALLEL_OK, NULL);
    1194             : 
    1195             :         /*
    1196             :          * Done with the snapshot used for parsing/planning.
    1197             :          *
    1198             :          * While it looks promising to reuse the same snapshot for query
    1199             :          * execution (at least for simple protocol), unfortunately it causes
    1200             :          * execution to use a snapshot that has been acquired before locking
    1201             :          * any of the tables mentioned in the query.  This creates user-
    1202             :          * visible anomalies, so refrain.  Refer to
    1203             :          * https://postgr.es/m/flat/5075D8DF.6050500@fuzzy.cz for details.
    1204             :          */
    1205      711058 :         if (snapshot_set)
    1206      363974 :             PopActiveSnapshot();
    1207             : 
    1208             :         /* If we got a cancel signal in analysis or planning, quit */
    1209      711058 :         CHECK_FOR_INTERRUPTS();
    1210             : 
    1211             :         /*
    1212             :          * Create unnamed portal to run the query or queries in. If there
    1213             :          * already is one, silently drop it.
    1214             :          */
    1215      711058 :         portal = CreatePortal("", true, true);
    1216             :         /* Don't display the portal in pg_cursors */
    1217      711058 :         portal->visible = false;
    1218             : 
    1219             :         /*
    1220             :          * We don't have to copy anything into the portal, because everything
    1221             :          * we are passing here is in MessageContext or the
    1222             :          * per_parsetree_context, and so will outlive the portal anyway.
    1223             :          */
    1224      711058 :         PortalDefineQuery(portal,
    1225             :                           NULL,
    1226             :                           query_string,
    1227             :                           commandTag,
    1228             :                           plantree_list,
    1229             :                           NULL,
    1230             :                           NULL);
    1231             : 
    1232             :         /*
    1233             :          * Start the portal.  No parameters here.
    1234             :          */
    1235      711058 :         PortalStart(portal, NULL, 0, InvalidSnapshot);
    1236             : 
    1237             :         /*
    1238             :          * Select the appropriate output format: text unless we are doing a
    1239             :          * FETCH from a binary cursor.  (Pretty grotty to have to do this here
    1240             :          * --- but it avoids grottiness in other places.  Ah, the joys of
    1241             :          * backward compatibility...)
    1242             :          */
    1243      710370 :         format = 0;             /* TEXT is default */
    1244      710370 :         if (IsA(parsetree->stmt, FetchStmt))
    1245             :         {
    1246        5780 :             FetchStmt  *stmt = (FetchStmt *) parsetree->stmt;
    1247             : 
    1248        5780 :             if (!stmt->ismove)
    1249             :             {
    1250        5712 :                 Portal      fportal = GetPortalByName(stmt->portalname);
    1251             : 
    1252        5712 :                 if (PortalIsValid(fportal) &&
    1253        5678 :                     (fportal->cursorOptions & CURSOR_OPT_BINARY))
    1254           8 :                     format = 1; /* BINARY */
    1255             :             }
    1256             :         }
    1257      710370 :         PortalSetResultFormat(portal, 1, &format);
    1258             : 
    1259             :         /*
    1260             :          * Now we can create the destination receiver object.
    1261             :          */
    1262      710370 :         receiver = CreateDestReceiver(dest);
    1263      710370 :         if (dest == DestRemote)
    1264      633666 :             SetRemoteDestReceiverParams(receiver, portal);
    1265             : 
    1266             :         /*
    1267             :          * Switch back to transaction context for execution.
    1268             :          */
    1269      710370 :         MemoryContextSwitchTo(oldcontext);
    1270             : 
    1271             :         /*
    1272             :          * Run the portal to completion, and then drop it (and the receiver).
    1273             :          */
    1274      710370 :         (void) PortalRun(portal,
    1275             :                          FETCH_ALL,
    1276             :                          true,  /* always top level */
    1277             :                          receiver,
    1278             :                          receiver,
    1279             :                          &qc);
    1280             : 
    1281      682360 :         receiver->rDestroy(receiver);
    1282             : 
    1283      682360 :         PortalDrop(portal, false);
    1284             : 
    1285      682360 :         if (lnext(parsetree_list, parsetree_item) == NULL)
    1286             :         {
    1287             :             /*
    1288             :              * If this is the last parsetree of the query string, close down
    1289             :              * transaction statement before reporting command-complete.  This
    1290             :              * is so that any end-of-transaction errors are reported before
    1291             :              * the command-complete message is issued, to avoid confusing
    1292             :              * clients who will expect either a command-complete message or an
    1293             :              * error, not one and then the other.  Also, if we're using an
    1294             :              * implicit transaction block, we must close that out first.
    1295             :              */
    1296      636920 :             if (use_implicit_block)
    1297       13598 :                 EndImplicitTransactionBlock();
    1298      636920 :             finish_xact_command();
    1299             :         }
    1300       45440 :         else if (IsA(parsetree->stmt, TransactionStmt))
    1301             :         {
    1302             :             /*
    1303             :              * If this was a transaction control statement, commit it. We will
    1304             :              * start a new xact command for the next command.
    1305             :              */
    1306        1058 :             finish_xact_command();
    1307             :         }
    1308             :         else
    1309             :         {
    1310             :             /*
    1311             :              * We had better not see XACT_FLAGS_NEEDIMMEDIATECOMMIT set if
    1312             :              * we're not calling finish_xact_command().  (The implicit
    1313             :              * transaction block should have prevented it from getting set.)
    1314             :              */
    1315             :             Assert(!(MyXactFlags & XACT_FLAGS_NEEDIMMEDIATECOMMIT));
    1316             : 
    1317             :             /*
    1318             :              * We need a CommandCounterIncrement after every query, except
    1319             :              * those that start or end a transaction block.
    1320             :              */
    1321       44382 :             CommandCounterIncrement();
    1322             : 
    1323             :             /*
    1324             :              * Disable statement timeout between queries of a multi-query
    1325             :              * string, so that the timeout applies separately to each query.
    1326             :              * (Our next loop iteration will start a fresh timeout.)
    1327             :              */
    1328       44382 :             disable_statement_timeout();
    1329             :         }
    1330             : 
    1331             :         /*
    1332             :          * Tell client that we're done with this query.  Note we emit exactly
    1333             :          * one EndCommand report for each raw parsetree, thus one for each SQL
    1334             :          * command the client sent, regardless of rewriting. (But a command
    1335             :          * aborted by error will not send an EndCommand report at all.)
    1336             :          */
    1337      681808 :         EndCommand(&qc, dest, false);
    1338             : 
    1339             :         /* Now we may drop the per-parsetree context, if one was created. */
    1340      681808 :         if (per_parsetree_context)
    1341       45440 :             MemoryContextDelete(per_parsetree_context);
    1342             :     }                           /* end loop over parsetrees */
    1343             : 
    1344             :     /*
    1345             :      * Close down transaction statement, if one is open.  (This will only do
    1346             :      * something if the parsetree list was empty; otherwise the last loop
    1347             :      * iteration already did it.)
    1348             :      */
    1349      637594 :     finish_xact_command();
    1350             : 
    1351             :     /*
    1352             :      * If there were no parsetrees, return EmptyQueryResponse message.
    1353             :      */
    1354      637594 :     if (!parsetree_list)
    1355        1226 :         NullCommand(dest);
    1356             : 
    1357             :     /*
    1358             :      * Emit duration logging if appropriate.
    1359             :      */
    1360      637594 :     switch (check_log_duration(msec_str, was_logged))
    1361             :     {
    1362          20 :         case 1:
    1363          20 :             ereport(LOG,
    1364             :                     (errmsg("duration: %s ms", msec_str),
    1365             :                      errhidestmt(true)));
    1366          20 :             break;
    1367           0 :         case 2:
    1368           0 :             ereport(LOG,
    1369             :                     (errmsg("duration: %s ms  statement: %s",
    1370             :                             msec_str, query_string),
    1371             :                      errhidestmt(true),
    1372             :                      errdetail_execute(parsetree_list)));
    1373           0 :             break;
    1374             :     }
    1375             : 
    1376      637594 :     if (save_log_statement_stats)
    1377           0 :         ShowUsage("QUERY STATISTICS");
    1378             : 
    1379             :     TRACE_POSTGRESQL_QUERY_DONE(query_string);
    1380             : 
    1381      637594 :     debug_query_string = NULL;
    1382      637594 : }
    1383             : 
    1384             : /*
    1385             :  * exec_parse_message
    1386             :  *
    1387             :  * Execute a "Parse" protocol message.
    1388             :  */
    1389             : static void
    1390       11124 : exec_parse_message(const char *query_string,    /* string to execute */
    1391             :                    const char *stmt_name,   /* name for prepared stmt */
    1392             :                    Oid *paramTypes, /* parameter types */
    1393             :                    int numParams)   /* number of parameters */
    1394             : {
    1395       11124 :     MemoryContext unnamed_stmt_context = NULL;
    1396             :     MemoryContext oldcontext;
    1397             :     List       *parsetree_list;
    1398             :     RawStmt    *raw_parse_tree;
    1399             :     List       *querytree_list;
    1400             :     CachedPlanSource *psrc;
    1401             :     bool        is_named;
    1402       11124 :     bool        save_log_statement_stats = log_statement_stats;
    1403             :     char        msec_str[32];
    1404             : 
    1405             :     /*
    1406             :      * Report query to various monitoring facilities.
    1407             :      */
    1408       11124 :     debug_query_string = query_string;
    1409             : 
    1410       11124 :     pgstat_report_activity(STATE_RUNNING, query_string);
    1411             : 
    1412       11124 :     set_ps_display("PARSE");
    1413             : 
    1414       11124 :     if (save_log_statement_stats)
    1415           0 :         ResetUsage();
    1416             : 
    1417       11124 :     ereport(DEBUG2,
    1418             :             (errmsg_internal("parse %s: %s",
    1419             :                              *stmt_name ? stmt_name : "<unnamed>",
    1420             :                              query_string)));
    1421             : 
    1422             :     /*
    1423             :      * Start up a transaction command so we can run parse analysis etc. (Note
    1424             :      * that this will normally change current memory context.) Nothing happens
    1425             :      * if we are already in one.  This also arms the statement timeout if
    1426             :      * necessary.
    1427             :      */
    1428       11124 :     start_xact_command();
    1429             : 
    1430             :     /*
    1431             :      * Switch to appropriate context for constructing parsetrees.
    1432             :      *
    1433             :      * We have two strategies depending on whether the prepared statement is
    1434             :      * named or not.  For a named prepared statement, we do parsing in
    1435             :      * MessageContext and copy the finished trees into the prepared
    1436             :      * statement's plancache entry; then the reset of MessageContext releases
    1437             :      * temporary space used by parsing and rewriting. For an unnamed prepared
    1438             :      * statement, we assume the statement isn't going to hang around long, so
    1439             :      * getting rid of temp space quickly is probably not worth the costs of
    1440             :      * copying parse trees.  So in this case, we create the plancache entry's
    1441             :      * query_context here, and do all the parsing work therein.
    1442             :      */
    1443       11124 :     is_named = (stmt_name[0] != '\0');
    1444       11124 :     if (is_named)
    1445             :     {
    1446             :         /* Named prepared statement --- parse in MessageContext */
    1447        4342 :         oldcontext = MemoryContextSwitchTo(MessageContext);
    1448             :     }
    1449             :     else
    1450             :     {
    1451             :         /* Unnamed prepared statement --- release any prior unnamed stmt */
    1452        6782 :         drop_unnamed_stmt();
    1453             :         /* Create context for parsing */
    1454             :         unnamed_stmt_context =
    1455        6782 :             AllocSetContextCreate(MessageContext,
    1456             :                                   "unnamed prepared statement",
    1457             :                                   ALLOCSET_DEFAULT_SIZES);
    1458        6782 :         oldcontext = MemoryContextSwitchTo(unnamed_stmt_context);
    1459             :     }
    1460             : 
    1461             :     /*
    1462             :      * Do basic parsing of the query or queries (this should be safe even if
    1463             :      * we are in aborted transaction state!)
    1464             :      */
    1465       11124 :     parsetree_list = pg_parse_query(query_string);
    1466             : 
    1467             :     /*
    1468             :      * We only allow a single user statement in a prepared statement. This is
    1469             :      * mainly to keep the protocol simple --- otherwise we'd need to worry
    1470             :      * about multiple result tupdescs and things like that.
    1471             :      */
    1472       11110 :     if (list_length(parsetree_list) > 1)
    1473           8 :         ereport(ERROR,
    1474             :                 (errcode(ERRCODE_SYNTAX_ERROR),
    1475             :                  errmsg("cannot insert multiple commands into a prepared statement")));
    1476             : 
    1477       11102 :     if (parsetree_list != NIL)
    1478             :     {
    1479       11096 :         bool        snapshot_set = false;
    1480             : 
    1481       11096 :         raw_parse_tree = linitial_node(RawStmt, parsetree_list);
    1482             : 
    1483             :         /*
    1484             :          * If we are in an aborted transaction, reject all commands except
    1485             :          * COMMIT/ROLLBACK.  It is important that this test occur before we
    1486             :          * try to do parse analysis, rewrite, or planning, since all those
    1487             :          * phases try to do database accesses, which may fail in abort state.
    1488             :          * (It might be safe to allow some additional utility commands in this
    1489             :          * state, but not many...)
    1490             :          */
    1491       11096 :         if (IsAbortedTransactionBlockState() &&
    1492           2 :             !IsTransactionExitStmt(raw_parse_tree->stmt))
    1493           2 :             ereport(ERROR,
    1494             :                     (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
    1495             :                      errmsg("current transaction is aborted, "
    1496             :                             "commands ignored until end of transaction block"),
    1497             :                      errdetail_abort()));
    1498             : 
    1499             :         /*
    1500             :          * Create the CachedPlanSource before we do parse analysis, since it
    1501             :          * needs to see the unmodified raw parse tree.
    1502             :          */
    1503       11094 :         psrc = CreateCachedPlan(raw_parse_tree, query_string,
    1504             :                                 CreateCommandTag(raw_parse_tree->stmt));
    1505             : 
    1506             :         /*
    1507             :          * Set up a snapshot if parse analysis will need one.
    1508             :          */
    1509       11094 :         if (analyze_requires_snapshot(raw_parse_tree))
    1510             :         {
    1511       10310 :             PushActiveSnapshot(GetTransactionSnapshot());
    1512       10310 :             snapshot_set = true;
    1513             :         }
    1514             : 
    1515             :         /*
    1516             :          * Analyze and rewrite the query.  Note that the originally specified
    1517             :          * parameter set is not required to be complete, so we have to use
    1518             :          * pg_analyze_and_rewrite_varparams().
    1519             :          */
    1520       11094 :         querytree_list = pg_analyze_and_rewrite_varparams(raw_parse_tree,
    1521             :                                                           query_string,
    1522             :                                                           &paramTypes,
    1523             :                                                           &numParams,
    1524             :                                                           NULL);
    1525             : 
    1526             :         /* Done with the snapshot used for parsing */
    1527       11072 :         if (snapshot_set)
    1528       10288 :             PopActiveSnapshot();
    1529             :     }
    1530             :     else
    1531             :     {
    1532             :         /* Empty input string.  This is legal. */
    1533           6 :         raw_parse_tree = NULL;
    1534           6 :         psrc = CreateCachedPlan(raw_parse_tree, query_string,
    1535             :                                 CMDTAG_UNKNOWN);
    1536           6 :         querytree_list = NIL;
    1537             :     }
    1538             : 
    1539             :     /*
    1540             :      * CachedPlanSource must be a direct child of MessageContext before we
    1541             :      * reparent unnamed_stmt_context under it, else we have a disconnected
    1542             :      * circular subgraph.  Klugy, but less so than flipping contexts even more
    1543             :      * above.
    1544             :      */
    1545       11078 :     if (unnamed_stmt_context)
    1546        6744 :         MemoryContextSetParent(psrc->context, MessageContext);
    1547             : 
    1548             :     /* Finish filling in the CachedPlanSource */
    1549       11078 :     CompleteCachedPlan(psrc,
    1550             :                        querytree_list,
    1551             :                        unnamed_stmt_context,
    1552             :                        paramTypes,
    1553             :                        numParams,
    1554             :                        NULL,
    1555             :                        NULL,
    1556             :                        CURSOR_OPT_PARALLEL_OK,  /* allow parallel mode */
    1557             :                        true);   /* fixed result */
    1558             : 
    1559             :     /* If we got a cancel signal during analysis, quit */
    1560       11078 :     CHECK_FOR_INTERRUPTS();
    1561             : 
    1562       11078 :     if (is_named)
    1563             :     {
    1564             :         /*
    1565             :          * Store the query as a prepared statement.
    1566             :          */
    1567        4334 :         StorePreparedStatement(stmt_name, psrc, false);
    1568             :     }
    1569             :     else
    1570             :     {
    1571             :         /*
    1572             :          * We just save the CachedPlanSource into unnamed_stmt_psrc.
    1573             :          */
    1574        6744 :         SaveCachedPlan(psrc);
    1575        6744 :         unnamed_stmt_psrc = psrc;
    1576             :     }
    1577             : 
    1578       11078 :     MemoryContextSwitchTo(oldcontext);
    1579             : 
    1580             :     /*
    1581             :      * We do NOT close the open transaction command here; that only happens
    1582             :      * when the client sends Sync.  Instead, do CommandCounterIncrement just
    1583             :      * in case something happened during parse/plan.
    1584             :      */
    1585       11078 :     CommandCounterIncrement();
    1586             : 
    1587             :     /*
    1588             :      * Send ParseComplete.
    1589             :      */
    1590       11078 :     if (whereToSendOutput == DestRemote)
    1591       11078 :         pq_putemptymessage(PqMsg_ParseComplete);
    1592             : 
    1593             :     /*
    1594             :      * Emit duration logging if appropriate.
    1595             :      */
    1596       11078 :     switch (check_log_duration(msec_str, false))
    1597             :     {
    1598           0 :         case 1:
    1599           0 :             ereport(LOG,
    1600             :                     (errmsg("duration: %s ms", msec_str),
    1601             :                      errhidestmt(true)));
    1602           0 :             break;
    1603          26 :         case 2:
    1604          26 :             ereport(LOG,
    1605             :                     (errmsg("duration: %s ms  parse %s: %s",
    1606             :                             msec_str,
    1607             :                             *stmt_name ? stmt_name : "<unnamed>",
    1608             :                             query_string),
    1609             :                      errhidestmt(true)));
    1610          26 :             break;
    1611             :     }
    1612             : 
    1613       11078 :     if (save_log_statement_stats)
    1614           0 :         ShowUsage("PARSE MESSAGE STATISTICS");
    1615             : 
    1616       11078 :     debug_query_string = NULL;
    1617       11078 : }
    1618             : 
    1619             : /*
    1620             :  * exec_bind_message
    1621             :  *
    1622             :  * Process a "Bind" message to create a portal from a prepared statement
    1623             :  */
    1624             : static void
    1625       21726 : exec_bind_message(StringInfo input_message)
    1626             : {
    1627             :     const char *portal_name;
    1628             :     const char *stmt_name;
    1629             :     int         numPFormats;
    1630       21726 :     int16      *pformats = NULL;
    1631             :     int         numParams;
    1632             :     int         numRFormats;
    1633       21726 :     int16      *rformats = NULL;
    1634             :     CachedPlanSource *psrc;
    1635             :     CachedPlan *cplan;
    1636             :     Portal      portal;
    1637             :     char       *query_string;
    1638             :     char       *saved_stmt_name;
    1639             :     ParamListInfo params;
    1640             :     MemoryContext oldContext;
    1641       21726 :     bool        save_log_statement_stats = log_statement_stats;
    1642       21726 :     bool        snapshot_set = false;
    1643             :     char        msec_str[32];
    1644             :     ParamsErrorCbData params_data;
    1645             :     ErrorContextCallback params_errcxt;
    1646             :     ListCell   *lc;
    1647             : 
    1648             :     /* Get the fixed part of the message */
    1649       21726 :     portal_name = pq_getmsgstring(input_message);
    1650       21726 :     stmt_name = pq_getmsgstring(input_message);
    1651             : 
    1652       21726 :     ereport(DEBUG2,
    1653             :             (errmsg_internal("bind %s to %s",
    1654             :                              *portal_name ? portal_name : "<unnamed>",
    1655             :                              *stmt_name ? stmt_name : "<unnamed>")));
    1656             : 
    1657             :     /* Find prepared statement */
    1658       21726 :     if (stmt_name[0] != '\0')
    1659             :     {
    1660             :         PreparedStatement *pstmt;
    1661             : 
    1662       15054 :         pstmt = FetchPreparedStatement(stmt_name, true);
    1663       15046 :         psrc = pstmt->plansource;
    1664             :     }
    1665             :     else
    1666             :     {
    1667             :         /* special-case the unnamed statement */
    1668        6672 :         psrc = unnamed_stmt_psrc;
    1669        6672 :         if (!psrc)
    1670           0 :             ereport(ERROR,
    1671             :                     (errcode(ERRCODE_UNDEFINED_PSTATEMENT),
    1672             :                      errmsg("unnamed prepared statement does not exist")));
    1673             :     }
    1674             : 
    1675             :     /*
    1676             :      * Report query to various monitoring facilities.
    1677             :      */
    1678       21718 :     debug_query_string = psrc->query_string;
    1679             : 
    1680       21718 :     pgstat_report_activity(STATE_RUNNING, psrc->query_string);
    1681             : 
    1682       43158 :     foreach(lc, psrc->query_list)
    1683             :     {
    1684       21718 :         Query      *query = lfirst_node(Query, lc);
    1685             : 
    1686       21718 :         if (query->queryId != UINT64CONST(0))
    1687             :         {
    1688         278 :             pgstat_report_query_id(query->queryId, false);
    1689         278 :             break;
    1690             :         }
    1691             :     }
    1692             : 
    1693       21718 :     set_ps_display("BIND");
    1694             : 
    1695       21718 :     if (save_log_statement_stats)
    1696           0 :         ResetUsage();
    1697             : 
    1698             :     /*
    1699             :      * Start up a transaction command so we can call functions etc. (Note that
    1700             :      * this will normally change current memory context.) Nothing happens if
    1701             :      * we are already in one.  This also arms the statement timeout if
    1702             :      * necessary.
    1703             :      */
    1704       21718 :     start_xact_command();
    1705             : 
    1706             :     /* Switch back to message context */
    1707       21718 :     MemoryContextSwitchTo(MessageContext);
    1708             : 
    1709             :     /* Get the parameter format codes */
    1710       21718 :     numPFormats = pq_getmsgint(input_message, 2);
    1711       21718 :     if (numPFormats > 0)
    1712             :     {
    1713        5108 :         pformats = palloc_array(int16, numPFormats);
    1714       12036 :         for (int i = 0; i < numPFormats; i++)
    1715        6928 :             pformats[i] = pq_getmsgint(input_message, 2);
    1716             :     }
    1717             : 
    1718             :     /* Get the parameter value count */
    1719       21718 :     numParams = pq_getmsgint(input_message, 2);
    1720             : 
    1721       21718 :     if (numPFormats > 1 && numPFormats != numParams)
    1722           0 :         ereport(ERROR,
    1723             :                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
    1724             :                  errmsg("bind message has %d parameter formats but %d parameters",
    1725             :                         numPFormats, numParams)));
    1726             : 
    1727       21718 :     if (numParams != psrc->num_params)
    1728          54 :         ereport(ERROR,
    1729             :                 (errcode(ERRCODE_PROTOCOL_VIOLATION),
    1730             :                  errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d",
    1731             :                         numParams, stmt_name, psrc->num_params)));
    1732             : 
    1733             :     /*
    1734             :      * If we are in aborted transaction state, the only portals we can
    1735             :      * actually run are those containing COMMIT or ROLLBACK commands. We
    1736             :      * disallow binding anything else to avoid problems with infrastructure
    1737             :      * that expects to run inside a valid transaction.  We also disallow
    1738             :      * binding any parameters, since we can't risk calling user-defined I/O
    1739             :      * functions.
    1740             :      */
    1741       21664 :     if (IsAbortedTransactionBlockState() &&
    1742           4 :         (!(psrc->raw_parse_tree &&
    1743           4 :            IsTransactionExitStmt(psrc->raw_parse_tree->stmt)) ||
    1744             :          numParams != 0))
    1745           0 :         ereport(ERROR,
    1746             :                 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
    1747             :                  errmsg("current transaction is aborted, "
    1748             :                         "commands ignored until end of transaction block"),
    1749             :                  errdetail_abort()));
    1750             : 
    1751             :     /*
    1752             :      * Create the portal.  Allow silent replacement of an existing portal only
    1753             :      * if the unnamed portal is specified.
    1754             :      */
    1755       21664 :     if (portal_name[0] == '\0')
    1756       21664 :         portal = CreatePortal(portal_name, true, true);
    1757             :     else
    1758           0 :         portal = CreatePortal(portal_name, false, false);
    1759             : 
    1760             :     /*
    1761             :      * Prepare to copy stuff into the portal's memory context.  We do all this
    1762             :      * copying first, because it could possibly fail (out-of-memory) and we
    1763             :      * don't want a failure to occur between GetCachedPlan and
    1764             :      * PortalDefineQuery; that would result in leaking our plancache refcount.
    1765             :      */
    1766       21664 :     oldContext = MemoryContextSwitchTo(portal->portalContext);
    1767             : 
    1768             :     /* Copy the plan's query string into the portal */
    1769       21664 :     query_string = pstrdup(psrc->query_string);
    1770             : 
    1771             :     /* Likewise make a copy of the statement name, unless it's unnamed */
    1772       21664 :     if (stmt_name[0])
    1773       15040 :         saved_stmt_name = pstrdup(stmt_name);
    1774             :     else
    1775        6624 :         saved_stmt_name = NULL;
    1776             : 
    1777             :     /*
    1778             :      * Set a snapshot if we have parameters to fetch (since the input
    1779             :      * functions might need it) or the query isn't a utility command (and
    1780             :      * hence could require redoing parse analysis and planning).  We keep the
    1781             :      * snapshot active till we're done, so that plancache.c doesn't have to
    1782             :      * take new ones.
    1783             :      */
    1784       21664 :     if (numParams > 0 ||
    1785        8692 :         (psrc->raw_parse_tree &&
    1786        4346 :          analyze_requires_snapshot(psrc->raw_parse_tree)))
    1787             :     {
    1788       19536 :         PushActiveSnapshot(GetTransactionSnapshot());
    1789       19536 :         snapshot_set = true;
    1790             :     }
    1791             : 
    1792             :     /*
    1793             :      * Fetch parameters, if any, and store in the portal's memory context.
    1794             :      */
    1795       21664 :     if (numParams > 0)
    1796             :     {
    1797       17318 :         char      **knownTextValues = NULL; /* allocate on first use */
    1798             :         BindParamCbData one_param_data;
    1799             : 
    1800             :         /*
    1801             :          * Set up an error callback so that if there's an error in this phase,
    1802             :          * we can report the specific parameter causing the problem.
    1803             :          */
    1804       17318 :         one_param_data.portalName = portal->name;
    1805       17318 :         one_param_data.paramno = -1;
    1806       17318 :         one_param_data.paramval = NULL;
    1807       17318 :         params_errcxt.previous = error_context_stack;
    1808       17318 :         params_errcxt.callback = bind_param_error_callback;
    1809       17318 :         params_errcxt.arg = &one_param_data;
    1810       17318 :         error_context_stack = &params_errcxt;
    1811             : 
    1812       17318 :         params = makeParamList(numParams);
    1813             : 
    1814       45704 :         for (int paramno = 0; paramno < numParams; paramno++)
    1815             :         {
    1816       28388 :             Oid         ptype = psrc->param_types[paramno];
    1817             :             int32       plength;
    1818             :             Datum       pval;
    1819             :             bool        isNull;
    1820             :             StringInfoData pbuf;
    1821             :             char        csave;
    1822             :             int16       pformat;
    1823             : 
    1824       28388 :             one_param_data.paramno = paramno;
    1825       28388 :             one_param_data.paramval = NULL;
    1826             : 
    1827       28388 :             plength = pq_getmsgint(input_message, 4);
    1828       28388 :             isNull = (plength == -1);
    1829             : 
    1830       28388 :             if (!isNull)
    1831             :             {
    1832             :                 char       *pvalue;
    1833             : 
    1834             :                 /*
    1835             :                  * Rather than copying data around, we just initialize a
    1836             :                  * StringInfo pointing to the correct portion of the message
    1837             :                  * buffer.  We assume we can scribble on the message buffer to
    1838             :                  * add a trailing NUL which is required for the input function
    1839             :                  * call.
    1840             :                  */
    1841       27170 :                 pvalue = unconstify(char *, pq_getmsgbytes(input_message, plength));
    1842       27170 :                 csave = pvalue[plength];
    1843       27170 :                 pvalue[plength] = '\0';
    1844       27170 :                 initReadOnlyStringInfo(&pbuf, pvalue, plength);
    1845             :             }
    1846             :             else
    1847             :             {
    1848        1218 :                 pbuf.data = NULL;   /* keep compiler quiet */
    1849        1218 :                 csave = 0;
    1850             :             }
    1851             : 
    1852       28388 :             if (numPFormats > 1)
    1853        3544 :                 pformat = pformats[paramno];
    1854       24844 :             else if (numPFormats > 0)
    1855        3384 :                 pformat = pformats[0];
    1856             :             else
    1857       21460 :                 pformat = 0;    /* default = text */
    1858             : 
    1859       28388 :             if (pformat == 0)   /* text mode */
    1860             :             {
    1861             :                 Oid         typinput;
    1862             :                 Oid         typioparam;
    1863             :                 char       *pstring;
    1864             : 
    1865       28336 :                 getTypeInputInfo(ptype, &typinput, &typioparam);
    1866             : 
    1867             :                 /*
    1868             :                  * We have to do encoding conversion before calling the
    1869             :                  * typinput routine.
    1870             :                  */
    1871       28336 :                 if (isNull)
    1872        1218 :                     pstring = NULL;
    1873             :                 else
    1874       27118 :                     pstring = pg_client_to_server(pbuf.data, plength);
    1875             : 
    1876             :                 /* Now we can log the input string in case of error */
    1877       28336 :                 one_param_data.paramval = pstring;
    1878             : 
    1879       28336 :                 pval = OidInputFunctionCall(typinput, pstring, typioparam, -1);
    1880             : 
    1881       28334 :                 one_param_data.paramval = NULL;
    1882             : 
    1883             :                 /*
    1884             :                  * If we might need to log parameters later, save a copy of
    1885             :                  * the converted string in MessageContext; then free the
    1886             :                  * result of encoding conversion, if any was done.
    1887             :                  */
    1888       28334 :                 if (pstring)
    1889             :                 {
    1890       27116 :                     if (log_parameter_max_length_on_error != 0)
    1891             :                     {
    1892             :                         MemoryContext oldcxt;
    1893             : 
    1894          14 :                         oldcxt = MemoryContextSwitchTo(MessageContext);
    1895             : 
    1896          14 :                         if (knownTextValues == NULL)
    1897          10 :                             knownTextValues = palloc0_array(char *, numParams);
    1898             : 
    1899          14 :                         if (log_parameter_max_length_on_error < 0)
    1900           8 :                             knownTextValues[paramno] = pstrdup(pstring);
    1901             :                         else
    1902             :                         {
    1903             :                             /*
    1904             :                              * We can trim the saved string, knowing that we
    1905             :                              * won't print all of it.  But we must copy at
    1906             :                              * least two more full characters than
    1907             :                              * BuildParamLogString wants to use; otherwise it
    1908             :                              * might fail to include the trailing ellipsis.
    1909             :                              */
    1910           6 :                             knownTextValues[paramno] =
    1911           6 :                                 pnstrdup(pstring,
    1912             :                                          log_parameter_max_length_on_error
    1913           6 :                                          + 2 * MAX_MULTIBYTE_CHAR_LEN);
    1914             :                         }
    1915             : 
    1916          14 :                         MemoryContextSwitchTo(oldcxt);
    1917             :                     }
    1918       27116 :                     if (pstring != pbuf.data)
    1919           0 :                         pfree(pstring);
    1920             :                 }
    1921             :             }
    1922          52 :             else if (pformat == 1)  /* binary mode */
    1923             :             {
    1924             :                 Oid         typreceive;
    1925             :                 Oid         typioparam;
    1926             :                 StringInfo  bufptr;
    1927             : 
    1928             :                 /*
    1929             :                  * Call the parameter type's binary input converter
    1930             :                  */
    1931          52 :                 getTypeBinaryInputInfo(ptype, &typreceive, &typioparam);
    1932             : 
    1933          52 :                 if (isNull)
    1934           0 :                     bufptr = NULL;
    1935             :                 else
    1936          52 :                     bufptr = &pbuf;
    1937             : 
    1938          52 :                 pval = OidReceiveFunctionCall(typreceive, bufptr, typioparam, -1);
    1939             : 
    1940             :                 /* Trouble if it didn't eat the whole buffer */
    1941          52 :                 if (!isNull && pbuf.cursor != pbuf.len)
    1942           0 :                     ereport(ERROR,
    1943             :                             (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
    1944             :                              errmsg("incorrect binary data format in bind parameter %d",
    1945             :                                     paramno + 1)));
    1946             :             }
    1947             :             else
    1948             :             {
    1949           0 :                 ereport(ERROR,
    1950             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1951             :                          errmsg("unsupported format code: %d",
    1952             :                                 pformat)));
    1953             :                 pval = 0;       /* keep compiler quiet */
    1954             :             }
    1955             : 
    1956             :             /* Restore message buffer contents */
    1957       28386 :             if (!isNull)
    1958       27168 :                 pbuf.data[plength] = csave;
    1959             : 
    1960       28386 :             params->params[paramno].value = pval;
    1961       28386 :             params->params[paramno].isnull = isNull;
    1962             : 
    1963             :             /*
    1964             :              * We mark the params as CONST.  This ensures that any custom plan
    1965             :              * makes full use of the parameter values.
    1966             :              */
    1967       28386 :             params->params[paramno].pflags = PARAM_FLAG_CONST;
    1968       28386 :             params->params[paramno].ptype = ptype;
    1969             :         }
    1970             : 
    1971             :         /* Pop the per-parameter error callback */
    1972       17316 :         error_context_stack = error_context_stack->previous;
    1973             : 
    1974             :         /*
    1975             :          * Once all parameters have been received, prepare for printing them
    1976             :          * in future errors, if configured to do so.  (This is saved in the
    1977             :          * portal, so that they'll appear when the query is executed later.)
    1978             :          */
    1979       17316 :         if (log_parameter_max_length_on_error != 0)
    1980           8 :             params->paramValuesStr =
    1981           8 :                 BuildParamLogString(params,
    1982             :                                     knownTextValues,
    1983             :                                     log_parameter_max_length_on_error);
    1984             :     }
    1985             :     else
    1986        4346 :         params = NULL;
    1987             : 
    1988             :     /* Done storing stuff in portal's context */
    1989       21662 :     MemoryContextSwitchTo(oldContext);
    1990             : 
    1991             :     /*
    1992             :      * Set up another error callback so that all the parameters are logged if
    1993             :      * we get an error during the rest of the BIND processing.
    1994             :      */
    1995       21662 :     params_data.portalName = portal->name;
    1996       21662 :     params_data.params = params;
    1997       21662 :     params_errcxt.previous = error_context_stack;
    1998       21662 :     params_errcxt.callback = ParamsErrorCallback;
    1999       21662 :     params_errcxt.arg = &params_data;
    2000       21662 :     error_context_stack = &params_errcxt;
    2001             : 
    2002             :     /* Get the result format codes */
    2003       21662 :     numRFormats = pq_getmsgint(input_message, 2);
    2004       21662 :     if (numRFormats > 0)
    2005             :     {
    2006       21662 :         rformats = palloc_array(int16, numRFormats);
    2007       43324 :         for (int i = 0; i < numRFormats; i++)
    2008       21662 :             rformats[i] = pq_getmsgint(input_message, 2);
    2009             :     }
    2010             : 
    2011       21662 :     pq_getmsgend(input_message);
    2012             : 
    2013             :     /*
    2014             :      * Obtain a plan from the CachedPlanSource.  Any cruft from (re)planning
    2015             :      * will be generated in MessageContext.  The plan refcount will be
    2016             :      * assigned to the Portal, so it will be released at portal destruction.
    2017             :      */
    2018       21662 :     cplan = GetCachedPlan(psrc, params, NULL, NULL);
    2019             : 
    2020             :     /*
    2021             :      * Now we can define the portal.
    2022             :      *
    2023             :      * DO NOT put any code that could possibly throw an error between the
    2024             :      * above GetCachedPlan call and here.
    2025             :      */
    2026       21660 :     PortalDefineQuery(portal,
    2027             :                       saved_stmt_name,
    2028             :                       query_string,
    2029             :                       psrc->commandTag,
    2030             :                       cplan->stmt_list,
    2031             :                       cplan,
    2032             :                       psrc);
    2033             : 
    2034             :     /* Portal is defined, set the plan ID based on its contents. */
    2035       43320 :     foreach(lc, portal->stmts)
    2036             :     {
    2037       21660 :         PlannedStmt *plan = lfirst_node(PlannedStmt, lc);
    2038             : 
    2039       21660 :         if (plan->planId != UINT64CONST(0))
    2040             :         {
    2041           0 :             pgstat_report_plan_id(plan->planId, false);
    2042           0 :             break;
    2043             :         }
    2044             :     }
    2045             : 
    2046             :     /* Done with the snapshot used for parameter I/O and parsing/planning */
    2047       21660 :     if (snapshot_set)
    2048       19532 :         PopActiveSnapshot();
    2049             : 
    2050             :     /*
    2051             :      * And we're ready to start portal execution.
    2052             :      */
    2053       21660 :     PortalStart(portal, params, 0, InvalidSnapshot);
    2054             : 
    2055             :     /*
    2056             :      * Apply the result format requests to the portal.
    2057             :      */
    2058       21660 :     PortalSetResultFormat(portal, numRFormats, rformats);
    2059             : 
    2060             :     /*
    2061             :      * Done binding; remove the parameters error callback.  Entries emitted
    2062             :      * later determine independently whether to log the parameters or not.
    2063             :      */
    2064       21660 :     error_context_stack = error_context_stack->previous;
    2065             : 
    2066             :     /*
    2067             :      * Send BindComplete.
    2068             :      */
    2069       21660 :     if (whereToSendOutput == DestRemote)
    2070       21660 :         pq_putemptymessage(PqMsg_BindComplete);
    2071             : 
    2072             :     /*
    2073             :      * Emit duration logging if appropriate.
    2074             :      */
    2075       21660 :     switch (check_log_duration(msec_str, false))
    2076             :     {
    2077           0 :         case 1:
    2078           0 :             ereport(LOG,
    2079             :                     (errmsg("duration: %s ms", msec_str),
    2080             :                      errhidestmt(true)));
    2081           0 :             break;
    2082          24 :         case 2:
    2083          24 :             ereport(LOG,
    2084             :                     (errmsg("duration: %s ms  bind %s%s%s: %s",
    2085             :                             msec_str,
    2086             :                             *stmt_name ? stmt_name : "<unnamed>",
    2087             :                             *portal_name ? "/" : "",
    2088             :                             *portal_name ? portal_name : "",
    2089             :                             psrc->query_string),
    2090             :                      errhidestmt(true),
    2091             :                      errdetail_params(params)));
    2092          24 :             break;
    2093             :     }
    2094             : 
    2095       21660 :     if (save_log_statement_stats)
    2096           0 :         ShowUsage("BIND MESSAGE STATISTICS");
    2097             : 
    2098             :     valgrind_report_error_query(debug_query_string);
    2099             : 
    2100       21660 :     debug_query_string = NULL;
    2101       21660 : }
    2102             : 
    2103             : /*
    2104             :  * exec_execute_message
    2105             :  *
    2106             :  * Process an "Execute" message for a portal
    2107             :  */
    2108             : static void
    2109       21660 : exec_execute_message(const char *portal_name, long max_rows)
    2110             : {
    2111             :     CommandDest dest;
    2112             :     DestReceiver *receiver;
    2113             :     Portal      portal;
    2114             :     bool        completed;
    2115             :     QueryCompletion qc;
    2116             :     const char *sourceText;
    2117             :     const char *prepStmtName;
    2118             :     ParamListInfo portalParams;
    2119       21660 :     bool        save_log_statement_stats = log_statement_stats;
    2120             :     bool        is_xact_command;
    2121             :     bool        execute_is_fetch;
    2122       21660 :     bool        was_logged = false;
    2123             :     char        msec_str[32];
    2124             :     ParamsErrorCbData params_data;
    2125             :     ErrorContextCallback params_errcxt;
    2126             :     const char *cmdtagname;
    2127             :     size_t      cmdtaglen;
    2128             :     ListCell   *lc;
    2129             : 
    2130             :     /* Adjust destination to tell printtup.c what to do */
    2131       21660 :     dest = whereToSendOutput;
    2132       21660 :     if (dest == DestRemote)
    2133       21660 :         dest = DestRemoteExecute;
    2134             : 
    2135       21660 :     portal = GetPortalByName(portal_name);
    2136       21660 :     if (!PortalIsValid(portal))
    2137           0 :         ereport(ERROR,
    2138             :                 (errcode(ERRCODE_UNDEFINED_CURSOR),
    2139             :                  errmsg("portal \"%s\" does not exist", portal_name)));
    2140             : 
    2141             :     /*
    2142             :      * If the original query was a null string, just return
    2143             :      * EmptyQueryResponse.
    2144             :      */
    2145       21660 :     if (portal->commandTag == CMDTAG_UNKNOWN)
    2146             :     {
    2147             :         Assert(portal->stmts == NIL);
    2148           0 :         NullCommand(dest);
    2149           0 :         return;
    2150             :     }
    2151             : 
    2152             :     /* Does the portal contain a transaction command? */
    2153       21660 :     is_xact_command = IsTransactionStmtList(portal->stmts);
    2154             : 
    2155             :     /*
    2156             :      * We must copy the sourceText and prepStmtName into MessageContext in
    2157             :      * case the portal is destroyed during finish_xact_command.  We do not
    2158             :      * make a copy of the portalParams though, preferring to just not print
    2159             :      * them in that case.
    2160             :      */
    2161       21660 :     sourceText = pstrdup(portal->sourceText);
    2162       21660 :     if (portal->prepStmtName)
    2163       15038 :         prepStmtName = pstrdup(portal->prepStmtName);
    2164             :     else
    2165        6622 :         prepStmtName = "<unnamed>";
    2166       21660 :     portalParams = portal->portalParams;
    2167             : 
    2168             :     /*
    2169             :      * Report query to various monitoring facilities.
    2170             :      */
    2171       21660 :     debug_query_string = sourceText;
    2172             : 
    2173       21660 :     pgstat_report_activity(STATE_RUNNING, sourceText);
    2174             : 
    2175       43060 :     foreach(lc, portal->stmts)
    2176             :     {
    2177       21660 :         PlannedStmt *stmt = lfirst_node(PlannedStmt, lc);
    2178             : 
    2179       21660 :         if (stmt->queryId != UINT64CONST(0))
    2180             :         {
    2181         260 :             pgstat_report_query_id(stmt->queryId, false);
    2182         260 :             break;
    2183             :         }
    2184             :     }
    2185             : 
    2186       43320 :     foreach(lc, portal->stmts)
    2187             :     {
    2188       21660 :         PlannedStmt *stmt = lfirst_node(PlannedStmt, lc);
    2189             : 
    2190       21660 :         if (stmt->planId != UINT64CONST(0))
    2191             :         {
    2192           0 :             pgstat_report_plan_id(stmt->planId, false);
    2193           0 :             break;
    2194             :         }
    2195             :     }
    2196             : 
    2197       21660 :     cmdtagname = GetCommandTagNameAndLen(portal->commandTag, &cmdtaglen);
    2198             : 
    2199       21660 :     set_ps_display_with_len(cmdtagname, cmdtaglen);
    2200             : 
    2201       21660 :     if (save_log_statement_stats)
    2202           0 :         ResetUsage();
    2203             : 
    2204       21660 :     BeginCommand(portal->commandTag, dest);
    2205             : 
    2206             :     /*
    2207             :      * Create dest receiver in MessageContext (we don't want it in transaction
    2208             :      * context, because that may get deleted if portal contains VACUUM).
    2209             :      */
    2210       21660 :     receiver = CreateDestReceiver(dest);
    2211       21660 :     if (dest == DestRemoteExecute)
    2212       21660 :         SetRemoteDestReceiverParams(receiver, portal);
    2213             : 
    2214             :     /*
    2215             :      * Ensure we are in a transaction command (this should normally be the
    2216             :      * case already due to prior BIND).
    2217             :      */
    2218       21660 :     start_xact_command();
    2219             : 
    2220             :     /*
    2221             :      * If we re-issue an Execute protocol request against an existing portal,
    2222             :      * then we are only fetching more rows rather than completely re-executing
    2223             :      * the query from the start. atStart is never reset for a v3 portal, so we
    2224             :      * are safe to use this check.
    2225             :      */
    2226       21660 :     execute_is_fetch = !portal->atStart;
    2227             : 
    2228             :     /* Log immediately if dictated by log_statement */
    2229       21660 :     if (check_log_statement(portal->stmts))
    2230             :     {
    2231        7738 :         ereport(LOG,
    2232             :                 (errmsg("%s %s%s%s: %s",
    2233             :                         execute_is_fetch ?
    2234             :                         _("execute fetch from") :
    2235             :                         _("execute"),
    2236             :                         prepStmtName,
    2237             :                         *portal_name ? "/" : "",
    2238             :                         *portal_name ? portal_name : "",
    2239             :                         sourceText),
    2240             :                  errhidestmt(true),
    2241             :                  errdetail_params(portalParams)));
    2242        7738 :         was_logged = true;
    2243             :     }
    2244             : 
    2245             :     /*
    2246             :      * If we are in aborted transaction state, the only portals we can
    2247             :      * actually run are those containing COMMIT or ROLLBACK commands.
    2248             :      */
    2249       21660 :     if (IsAbortedTransactionBlockState() &&
    2250           2 :         !IsTransactionExitStmtList(portal->stmts))
    2251           0 :         ereport(ERROR,
    2252             :                 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
    2253             :                  errmsg("current transaction is aborted, "
    2254             :                         "commands ignored until end of transaction block"),
    2255             :                  errdetail_abort()));
    2256             : 
    2257             :     /* Check for cancel signal before we start execution */
    2258       21660 :     CHECK_FOR_INTERRUPTS();
    2259             : 
    2260             :     /*
    2261             :      * Okay to run the portal.  Set the error callback so that parameters are
    2262             :      * logged.  The parameters must have been saved during the bind phase.
    2263             :      */
    2264       21660 :     params_data.portalName = portal->name;
    2265       21660 :     params_data.params = portalParams;
    2266       21660 :     params_errcxt.previous = error_context_stack;
    2267       21660 :     params_errcxt.callback = ParamsErrorCallback;
    2268       21660 :     params_errcxt.arg = &params_data;
    2269       21660 :     error_context_stack = &params_errcxt;
    2270             : 
    2271       21660 :     if (max_rows <= 0)
    2272       21660 :         max_rows = FETCH_ALL;
    2273             : 
    2274       21660 :     completed = PortalRun(portal,
    2275             :                           max_rows,
    2276             :                           true, /* always top level */
    2277             :                           receiver,
    2278             :                           receiver,
    2279             :                           &qc);
    2280             : 
    2281       21560 :     receiver->rDestroy(receiver);
    2282             : 
    2283             :     /* Done executing; remove the params error callback */
    2284       21560 :     error_context_stack = error_context_stack->previous;
    2285             : 
    2286       21560 :     if (completed)
    2287             :     {
    2288       21560 :         if (is_xact_command || (MyXactFlags & XACT_FLAGS_NEEDIMMEDIATECOMMIT))
    2289             :         {
    2290             :             /*
    2291             :              * If this was a transaction control statement, commit it.  We
    2292             :              * will start a new xact command for the next command (if any).
    2293             :              * Likewise if the statement required immediate commit.  Without
    2294             :              * this provision, we wouldn't force commit until Sync is
    2295             :              * received, which creates a hazard if the client tries to
    2296             :              * pipeline immediate-commit statements.
    2297             :              */
    2298         946 :             finish_xact_command();
    2299             : 
    2300             :             /*
    2301             :              * These commands typically don't have any parameters, and even if
    2302             :              * one did we couldn't print them now because the storage went
    2303             :              * away during finish_xact_command.  So pretend there were none.
    2304             :              */
    2305         946 :             portalParams = NULL;
    2306             :         }
    2307             :         else
    2308             :         {
    2309             :             /*
    2310             :              * We need a CommandCounterIncrement after every query, except
    2311             :              * those that start or end a transaction block.
    2312             :              */
    2313       20614 :             CommandCounterIncrement();
    2314             : 
    2315             :             /*
    2316             :              * Set XACT_FLAGS_PIPELINING whenever we complete an Execute
    2317             :              * message without immediately committing the transaction.
    2318             :              */
    2319       20614 :             MyXactFlags |= XACT_FLAGS_PIPELINING;
    2320             : 
    2321             :             /*
    2322             :              * Disable statement timeout whenever we complete an Execute
    2323             :              * message.  The next protocol message will start a fresh timeout.
    2324             :              */
    2325       20614 :             disable_statement_timeout();
    2326             :         }
    2327             : 
    2328             :         /* Send appropriate CommandComplete to client */
    2329       21560 :         EndCommand(&qc, dest, false);
    2330             :     }
    2331             :     else
    2332             :     {
    2333             :         /* Portal run not complete, so send PortalSuspended */
    2334           0 :         if (whereToSendOutput == DestRemote)
    2335           0 :             pq_putemptymessage(PqMsg_PortalSuspended);
    2336             : 
    2337             :         /*
    2338             :          * Set XACT_FLAGS_PIPELINING whenever we suspend an Execute message,
    2339             :          * too.
    2340             :          */
    2341           0 :         MyXactFlags |= XACT_FLAGS_PIPELINING;
    2342             :     }
    2343             : 
    2344             :     /*
    2345             :      * Emit duration logging if appropriate.
    2346             :      */
    2347       21560 :     switch (check_log_duration(msec_str, was_logged))
    2348             :     {
    2349          16 :         case 1:
    2350          16 :             ereport(LOG,
    2351             :                     (errmsg("duration: %s ms", msec_str),
    2352             :                      errhidestmt(true)));
    2353          16 :             break;
    2354           0 :         case 2:
    2355           0 :             ereport(LOG,
    2356             :                     (errmsg("duration: %s ms  %s %s%s%s: %s",
    2357             :                             msec_str,
    2358             :                             execute_is_fetch ?
    2359             :                             _("execute fetch from") :
    2360             :                             _("execute"),
    2361             :                             prepStmtName,
    2362             :                             *portal_name ? "/" : "",
    2363             :                             *portal_name ? portal_name : "",
    2364             :                             sourceText),
    2365             :                      errhidestmt(true),
    2366             :                      errdetail_params(portalParams)));
    2367           0 :             break;
    2368             :     }
    2369             : 
    2370       21560 :     if (save_log_statement_stats)
    2371           0 :         ShowUsage("EXECUTE MESSAGE STATISTICS");
    2372             : 
    2373             :     valgrind_report_error_query(debug_query_string);
    2374             : 
    2375       21560 :     debug_query_string = NULL;
    2376             : }
    2377             : 
    2378             : /*
    2379             :  * check_log_statement
    2380             :  *      Determine whether command should be logged because of log_statement
    2381             :  *
    2382             :  * stmt_list can be either raw grammar output or a list of planned
    2383             :  * statements
    2384             :  */
    2385             : static bool
    2386      700808 : check_log_statement(List *stmt_list)
    2387             : {
    2388             :     ListCell   *stmt_item;
    2389             : 
    2390      700808 :     if (log_statement == LOGSTMT_NONE)
    2391      434758 :         return false;
    2392      266050 :     if (log_statement == LOGSTMT_ALL)
    2393      266050 :         return true;
    2394             : 
    2395             :     /* Else we have to inspect the statement(s) to see whether to log */
    2396           0 :     foreach(stmt_item, stmt_list)
    2397             :     {
    2398           0 :         Node       *stmt = (Node *) lfirst(stmt_item);
    2399             : 
    2400           0 :         if (GetCommandLogLevel(stmt) <= log_statement)
    2401           0 :             return true;
    2402             :     }
    2403             : 
    2404           0 :     return false;
    2405             : }
    2406             : 
    2407             : /*
    2408             :  * check_log_duration
    2409             :  *      Determine whether current command's duration should be logged
    2410             :  *      We also check if this statement in this transaction must be logged
    2411             :  *      (regardless of its duration).
    2412             :  *
    2413             :  * Returns:
    2414             :  *      0 if no logging is needed
    2415             :  *      1 if just the duration should be logged
    2416             :  *      2 if duration and query details should be logged
    2417             :  *
    2418             :  * If logging is needed, the duration in msec is formatted into msec_str[],
    2419             :  * which must be a 32-byte buffer.
    2420             :  *
    2421             :  * was_logged should be true if caller already logged query details (this
    2422             :  * essentially prevents 2 from being returned).
    2423             :  */
    2424             : int
    2425      694100 : check_log_duration(char *msec_str, bool was_logged)
    2426             : {
    2427      694100 :     if (log_duration || log_min_duration_sample >= 0 ||
    2428      694100 :         log_min_duration_statement >= 0 || xact_is_sampled)
    2429             :     {
    2430             :         long        secs;
    2431             :         int         usecs;
    2432             :         int         msecs;
    2433             :         bool        exceeded_duration;
    2434             :         bool        exceeded_sample_duration;
    2435          86 :         bool        in_sample = false;
    2436             : 
    2437          86 :         TimestampDifference(GetCurrentStatementStartTimestamp(),
    2438             :                             GetCurrentTimestamp(),
    2439             :                             &secs, &usecs);
    2440          86 :         msecs = usecs / 1000;
    2441             : 
    2442             :         /*
    2443             :          * This odd-looking test for log_min_duration_* being exceeded is
    2444             :          * designed to avoid integer overflow with very long durations: don't
    2445             :          * compute secs * 1000 until we've verified it will fit in int.
    2446             :          */
    2447          86 :         exceeded_duration = (log_min_duration_statement == 0 ||
    2448           0 :                              (log_min_duration_statement > 0 &&
    2449           0 :                               (secs > log_min_duration_statement / 1000 ||
    2450           0 :                                secs * 1000 + msecs >= log_min_duration_statement)));
    2451             : 
    2452         172 :         exceeded_sample_duration = (log_min_duration_sample == 0 ||
    2453          86 :                                     (log_min_duration_sample > 0 &&
    2454           0 :                                      (secs > log_min_duration_sample / 1000 ||
    2455           0 :                                       secs * 1000 + msecs >= log_min_duration_sample)));
    2456             : 
    2457             :         /*
    2458             :          * Do not log if log_statement_sample_rate = 0. Log a sample if
    2459             :          * log_statement_sample_rate <= 1 and avoid unnecessary PRNG call if
    2460             :          * log_statement_sample_rate = 1.
    2461             :          */
    2462          86 :         if (exceeded_sample_duration)
    2463           0 :             in_sample = log_statement_sample_rate != 0 &&
    2464           0 :                 (log_statement_sample_rate == 1 ||
    2465           0 :                  pg_prng_double(&pg_global_prng_state) <= log_statement_sample_rate);
    2466             : 
    2467          86 :         if (exceeded_duration || in_sample || log_duration || xact_is_sampled)
    2468             :         {
    2469          86 :             snprintf(msec_str, 32, "%ld.%03d",
    2470          86 :                      secs * 1000 + msecs, usecs % 1000);
    2471          86 :             if ((exceeded_duration || in_sample || xact_is_sampled) && !was_logged)
    2472          86 :                 return 2;
    2473             :             else
    2474          36 :                 return 1;
    2475             :         }
    2476             :     }
    2477             : 
    2478      694014 :     return 0;
    2479             : }
    2480             : 
    2481             : /*
    2482             :  * errdetail_execute
    2483             :  *
    2484             :  * Add an errdetail() line showing the query referenced by an EXECUTE, if any.
    2485             :  * The argument is the raw parsetree list.
    2486             :  */
    2487             : static int
    2488      258312 : errdetail_execute(List *raw_parsetree_list)
    2489             : {
    2490             :     ListCell   *parsetree_item;
    2491             : 
    2492      505446 :     foreach(parsetree_item, raw_parsetree_list)
    2493             :     {
    2494      258326 :         RawStmt    *parsetree = lfirst_node(RawStmt, parsetree_item);
    2495             : 
    2496      258326 :         if (IsA(parsetree->stmt, ExecuteStmt))
    2497             :         {
    2498       11192 :             ExecuteStmt *stmt = (ExecuteStmt *) parsetree->stmt;
    2499             :             PreparedStatement *pstmt;
    2500             : 
    2501       11192 :             pstmt = FetchPreparedStatement(stmt->name, false);
    2502       11192 :             if (pstmt)
    2503             :             {
    2504       11192 :                 errdetail("prepare: %s", pstmt->plansource->query_string);
    2505       11192 :                 return 0;
    2506             :             }
    2507             :         }
    2508             :     }
    2509             : 
    2510      247120 :     return 0;
    2511             : }
    2512             : 
    2513             : /*
    2514             :  * errdetail_params
    2515             :  *
    2516             :  * Add an errdetail() line showing bind-parameter data, if available.
    2517             :  * Note that this is only used for statement logging, so it is controlled
    2518             :  * by log_parameter_max_length not log_parameter_max_length_on_error.
    2519             :  */
    2520             : static int
    2521        7762 : errdetail_params(ParamListInfo params)
    2522             : {
    2523        7762 :     if (params && params->numParams > 0 && log_parameter_max_length != 0)
    2524             :     {
    2525             :         char       *str;
    2526             : 
    2527        4764 :         str = BuildParamLogString(params, NULL, log_parameter_max_length);
    2528        4764 :         if (str && str[0] != '\0')
    2529        4764 :             errdetail("Parameters: %s", str);
    2530             :     }
    2531             : 
    2532        7762 :     return 0;
    2533             : }
    2534             : 
    2535             : /*
    2536             :  * errdetail_abort
    2537             :  *
    2538             :  * Add an errdetail() line showing abort reason, if any.
    2539             :  */
    2540             : static int
    2541          94 : errdetail_abort(void)
    2542             : {
    2543          94 :     if (MyProc->recoveryConflictPending)
    2544           0 :         errdetail("Abort reason: recovery conflict");
    2545             : 
    2546          94 :     return 0;
    2547             : }
    2548             : 
    2549             : /*
    2550             :  * errdetail_recovery_conflict
    2551             :  *
    2552             :  * Add an errdetail() line showing conflict source.
    2553             :  */
    2554             : static int
    2555          24 : errdetail_recovery_conflict(ProcSignalReason reason)
    2556             : {
    2557          24 :     switch (reason)
    2558             :     {
    2559           2 :         case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
    2560           2 :             errdetail("User was holding shared buffer pin for too long.");
    2561           2 :             break;
    2562           2 :         case PROCSIG_RECOVERY_CONFLICT_LOCK:
    2563           2 :             errdetail("User was holding a relation lock for too long.");
    2564           2 :             break;
    2565           2 :         case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
    2566           2 :             errdetail("User was or might have been using tablespace that must be dropped.");
    2567           2 :             break;
    2568           2 :         case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
    2569           2 :             errdetail("User query might have needed to see row versions that must be removed.");
    2570           2 :             break;
    2571          10 :         case PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT:
    2572          10 :             errdetail("User was using a logical replication slot that must be invalidated.");
    2573          10 :             break;
    2574           2 :         case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
    2575           2 :             errdetail("User transaction caused buffer deadlock with recovery.");
    2576           2 :             break;
    2577           4 :         case PROCSIG_RECOVERY_CONFLICT_DATABASE:
    2578           4 :             errdetail("User was connected to a database that must be dropped.");
    2579           4 :             break;
    2580           0 :         default:
    2581           0 :             break;
    2582             :             /* no errdetail */
    2583             :     }
    2584             : 
    2585          24 :     return 0;
    2586             : }
    2587             : 
    2588             : /*
    2589             :  * bind_param_error_callback
    2590             :  *
    2591             :  * Error context callback used while parsing parameters in a Bind message
    2592             :  */
    2593             : static void
    2594           2 : bind_param_error_callback(void *arg)
    2595             : {
    2596           2 :     BindParamCbData *data = (BindParamCbData *) arg;
    2597             :     StringInfoData buf;
    2598             :     char       *quotedval;
    2599             : 
    2600           2 :     if (data->paramno < 0)
    2601           0 :         return;
    2602             : 
    2603             :     /* If we have a textual value, quote it, and trim if necessary */
    2604           2 :     if (data->paramval)
    2605             :     {
    2606           2 :         initStringInfo(&buf);
    2607           2 :         appendStringInfoStringQuoted(&buf, data->paramval,
    2608             :                                      log_parameter_max_length_on_error);
    2609           2 :         quotedval = buf.data;
    2610             :     }
    2611             :     else
    2612           0 :         quotedval = NULL;
    2613             : 
    2614           2 :     if (data->portalName && data->portalName[0] != '\0')
    2615             :     {
    2616           0 :         if (quotedval)
    2617           0 :             errcontext("portal \"%s\" parameter $%d = %s",
    2618           0 :                        data->portalName, data->paramno + 1, quotedval);
    2619             :         else
    2620           0 :             errcontext("portal \"%s\" parameter $%d",
    2621           0 :                        data->portalName, data->paramno + 1);
    2622             :     }
    2623             :     else
    2624             :     {
    2625           2 :         if (quotedval)
    2626           2 :             errcontext("unnamed portal parameter $%d = %s",
    2627           2 :                        data->paramno + 1, quotedval);
    2628             :         else
    2629           0 :             errcontext("unnamed portal parameter $%d",
    2630           0 :                        data->paramno + 1);
    2631             :     }
    2632             : 
    2633           2 :     if (quotedval)
    2634           2 :         pfree(quotedval);
    2635             : }
    2636             : 
    2637             : /*
    2638             :  * exec_describe_statement_message
    2639             :  *
    2640             :  * Process a "Describe" message for a prepared statement
    2641             :  */
    2642             : static void
    2643         142 : exec_describe_statement_message(const char *stmt_name)
    2644             : {
    2645             :     CachedPlanSource *psrc;
    2646             : 
    2647             :     /*
    2648             :      * Start up a transaction command. (Note that this will normally change
    2649             :      * current memory context.) Nothing happens if we are already in one.
    2650             :      */
    2651         142 :     start_xact_command();
    2652             : 
    2653             :     /* Switch back to message context */
    2654         142 :     MemoryContextSwitchTo(MessageContext);
    2655             : 
    2656             :     /* Find prepared statement */
    2657         142 :     if (stmt_name[0] != '\0')
    2658             :     {
    2659             :         PreparedStatement *pstmt;
    2660             : 
    2661          88 :         pstmt = FetchPreparedStatement(stmt_name, true);
    2662          86 :         psrc = pstmt->plansource;
    2663             :     }
    2664             :     else
    2665             :     {
    2666             :         /* special-case the unnamed statement */
    2667          54 :         psrc = unnamed_stmt_psrc;
    2668          54 :         if (!psrc)
    2669           0 :             ereport(ERROR,
    2670             :                     (errcode(ERRCODE_UNDEFINED_PSTATEMENT),
    2671             :                      errmsg("unnamed prepared statement does not exist")));
    2672             :     }
    2673             : 
    2674             :     /* Prepared statements shouldn't have changeable result descs */
    2675             :     Assert(psrc->fixed_result);
    2676             : 
    2677             :     /*
    2678             :      * If we are in aborted transaction state, we can't run
    2679             :      * SendRowDescriptionMessage(), because that needs catalog accesses.
    2680             :      * Hence, refuse to Describe statements that return data.  (We shouldn't
    2681             :      * just refuse all Describes, since that might break the ability of some
    2682             :      * clients to issue COMMIT or ROLLBACK commands, if they use code that
    2683             :      * blindly Describes whatever it does.)  We can Describe parameters
    2684             :      * without doing anything dangerous, so we don't restrict that.
    2685             :      */
    2686         140 :     if (IsAbortedTransactionBlockState() &&
    2687           6 :         psrc->resultDesc)
    2688           0 :         ereport(ERROR,
    2689             :                 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
    2690             :                  errmsg("current transaction is aborted, "
    2691             :                         "commands ignored until end of transaction block"),
    2692             :                  errdetail_abort()));
    2693             : 
    2694         140 :     if (whereToSendOutput != DestRemote)
    2695           0 :         return;                 /* can't actually do anything... */
    2696             : 
    2697             :     /*
    2698             :      * First describe the parameters...
    2699             :      */
    2700         140 :     pq_beginmessage_reuse(&row_description_buf, PqMsg_ParameterDescription);
    2701         140 :     pq_sendint16(&row_description_buf, psrc->num_params);
    2702             : 
    2703         154 :     for (int i = 0; i < psrc->num_params; i++)
    2704             :     {
    2705          14 :         Oid         ptype = psrc->param_types[i];
    2706             : 
    2707          14 :         pq_sendint32(&row_description_buf, (int) ptype);
    2708             :     }
    2709         140 :     pq_endmessage_reuse(&row_description_buf);
    2710             : 
    2711             :     /*
    2712             :      * Next send RowDescription or NoData to describe the result...
    2713             :      */
    2714         140 :     if (psrc->resultDesc)
    2715             :     {
    2716             :         List       *tlist;
    2717             : 
    2718             :         /* Get the plan's primary targetlist */
    2719         128 :         tlist = CachedPlanGetTargetList(psrc, NULL);
    2720             : 
    2721         128 :         SendRowDescriptionMessage(&row_description_buf,
    2722             :                                   psrc->resultDesc,
    2723             :                                   tlist,
    2724             :                                   NULL);
    2725             :     }
    2726             :     else
    2727          12 :         pq_putemptymessage(PqMsg_NoData);
    2728             : }
    2729             : 
    2730             : /*
    2731             :  * exec_describe_portal_message
    2732             :  *
    2733             :  * Process a "Describe" message for a portal
    2734             :  */
    2735             : static void
    2736       21664 : exec_describe_portal_message(const char *portal_name)
    2737             : {
    2738             :     Portal      portal;
    2739             : 
    2740             :     /*
    2741             :      * Start up a transaction command. (Note that this will normally change
    2742             :      * current memory context.) Nothing happens if we are already in one.
    2743             :      */
    2744       21664 :     start_xact_command();
    2745             : 
    2746             :     /* Switch back to message context */
    2747       21664 :     MemoryContextSwitchTo(MessageContext);
    2748             : 
    2749       21664 :     portal = GetPortalByName(portal_name);
    2750       21664 :     if (!PortalIsValid(portal))
    2751           2 :         ereport(ERROR,
    2752             :                 (errcode(ERRCODE_UNDEFINED_CURSOR),
    2753             :                  errmsg("portal \"%s\" does not exist", portal_name)));
    2754             : 
    2755             :     /*
    2756             :      * If we are in aborted transaction state, we can't run
    2757             :      * SendRowDescriptionMessage(), because that needs catalog accesses.
    2758             :      * Hence, refuse to Describe portals that return data.  (We shouldn't just
    2759             :      * refuse all Describes, since that might break the ability of some
    2760             :      * clients to issue COMMIT or ROLLBACK commands, if they use code that
    2761             :      * blindly Describes whatever it does.)
    2762             :      */
    2763       21662 :     if (IsAbortedTransactionBlockState() &&
    2764           2 :         portal->tupDesc)
    2765           0 :         ereport(ERROR,
    2766             :                 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
    2767             :                  errmsg("current transaction is aborted, "
    2768             :                         "commands ignored until end of transaction block"),
    2769             :                  errdetail_abort()));
    2770             : 
    2771       21662 :     if (whereToSendOutput != DestRemote)
    2772           0 :         return;                 /* can't actually do anything... */
    2773             : 
    2774       21662 :     if (portal->tupDesc)
    2775        9018 :         SendRowDescriptionMessage(&row_description_buf,
    2776             :                                   portal->tupDesc,
    2777             :                                   FetchPortalTargetList(portal),
    2778             :                                   portal->formats);
    2779             :     else
    2780       12644 :         pq_putemptymessage(PqMsg_NoData);
    2781             : }
    2782             : 
    2783             : 
    2784             : /*
    2785             :  * Convenience routines for starting/committing a single command.
    2786             :  */
    2787             : static void
    2788     1482082 : start_xact_command(void)
    2789             : {
    2790     1482082 :     if (!xact_started)
    2791             :     {
    2792      706448 :         StartTransactionCommand();
    2793             : 
    2794      706448 :         xact_started = true;
    2795             :     }
    2796      775634 :     else if (MyXactFlags & XACT_FLAGS_PIPELINING)
    2797             :     {
    2798             :         /*
    2799             :          * When the first Execute message is completed, following commands
    2800             :          * will be done in an implicit transaction block created via
    2801             :          * pipelining. The transaction state needs to be updated to an
    2802             :          * implicit block if we're not already in a transaction block (like
    2803             :          * one started by an explicit BEGIN).
    2804             :          */
    2805       31322 :         BeginImplicitTransactionBlock();
    2806             :     }
    2807             : 
    2808             :     /*
    2809             :      * Start statement timeout if necessary.  Note that this'll intentionally
    2810             :      * not reset the clock on an already started timeout, to avoid the timing
    2811             :      * overhead when start_xact_command() is invoked repeatedly, without an
    2812             :      * interceding finish_xact_command() (e.g. parse/bind/execute).  If that's
    2813             :      * not desired, the timeout has to be disabled explicitly.
    2814             :      */
    2815     1482082 :     enable_statement_timeout();
    2816             : 
    2817             :     /* Start timeout for checking if the client has gone away if necessary. */
    2818     1482082 :     if (client_connection_check_interval > 0 &&
    2819           0 :         IsUnderPostmaster &&
    2820           0 :         MyProcPort &&
    2821           0 :         !get_timeout_active(CLIENT_CONNECTION_CHECK_TIMEOUT))
    2822           0 :         enable_timeout_after(CLIENT_CONNECTION_CHECK_TIMEOUT,
    2823             :                              client_connection_check_interval);
    2824     1482082 : }
    2825             : 
    2826             : static void
    2827     1301614 : finish_xact_command(void)
    2828             : {
    2829             :     /* cancel active statement timeout after each command */
    2830     1301614 :     disable_statement_timeout();
    2831             : 
    2832     1301614 :     if (xact_started)
    2833             :     {
    2834      664084 :         CommitTransactionCommand();
    2835             : 
    2836             : #ifdef MEMORY_CONTEXT_CHECKING
    2837             :         /* Check all memory contexts that weren't freed during commit */
    2838             :         /* (those that were, were checked before being deleted) */
    2839             :         MemoryContextCheck(TopMemoryContext);
    2840             : #endif
    2841             : 
    2842             : #ifdef SHOW_MEMORY_STATS
    2843             :         /* Print mem stats after each commit for leak tracking */
    2844             :         MemoryContextStats(TopMemoryContext);
    2845             : #endif
    2846             : 
    2847      663532 :         xact_started = false;
    2848             :     }
    2849     1301062 : }
    2850             : 
    2851             : 
    2852             : /*
    2853             :  * Convenience routines for checking whether a statement is one of the
    2854             :  * ones that we allow in transaction-aborted state.
    2855             :  */
    2856             : 
    2857             : /* Test a bare parsetree */
    2858             : static bool
    2859        1756 : IsTransactionExitStmt(Node *parsetree)
    2860             : {
    2861        1756 :     if (parsetree && IsA(parsetree, TransactionStmt))
    2862             :     {
    2863        1674 :         TransactionStmt *stmt = (TransactionStmt *) parsetree;
    2864             : 
    2865        1674 :         if (stmt->kind == TRANS_STMT_COMMIT ||
    2866         906 :             stmt->kind == TRANS_STMT_PREPARE ||
    2867         902 :             stmt->kind == TRANS_STMT_ROLLBACK ||
    2868         220 :             stmt->kind == TRANS_STMT_ROLLBACK_TO)
    2869        1662 :             return true;
    2870             :     }
    2871          94 :     return false;
    2872             : }
    2873             : 
    2874             : /* Test a list that contains PlannedStmt nodes */
    2875             : static bool
    2876           2 : IsTransactionExitStmtList(List *pstmts)
    2877             : {
    2878           2 :     if (list_length(pstmts) == 1)
    2879             :     {
    2880           2 :         PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts);
    2881             : 
    2882           4 :         if (pstmt->commandType == CMD_UTILITY &&
    2883           2 :             IsTransactionExitStmt(pstmt->utilityStmt))
    2884           2 :             return true;
    2885             :     }
    2886           0 :     return false;
    2887             : }
    2888             : 
    2889             : /* Test a list that contains PlannedStmt nodes */
    2890             : static bool
    2891       21660 : IsTransactionStmtList(List *pstmts)
    2892             : {
    2893       21660 :     if (list_length(pstmts) == 1)
    2894             :     {
    2895       21660 :         PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts);
    2896             : 
    2897       21660 :         if (pstmt->commandType == CMD_UTILITY &&
    2898        3804 :             IsA(pstmt->utilityStmt, TransactionStmt))
    2899         954 :             return true;
    2900             :     }
    2901       20706 :     return false;
    2902             : }
    2903             : 
    2904             : /* Release any existing unnamed prepared statement */
    2905             : static void
    2906      687084 : drop_unnamed_stmt(void)
    2907             : {
    2908             :     /* paranoia to avoid a dangling pointer in case of error */
    2909      687084 :     if (unnamed_stmt_psrc)
    2910             :     {
    2911        6478 :         CachedPlanSource *psrc = unnamed_stmt_psrc;
    2912             : 
    2913        6478 :         unnamed_stmt_psrc = NULL;
    2914        6478 :         DropCachedPlan(psrc);
    2915             :     }
    2916      687084 : }
    2917             : 
    2918             : 
    2919             : /* --------------------------------
    2920             :  *      signal handler routines used in PostgresMain()
    2921             :  * --------------------------------
    2922             :  */
    2923             : 
    2924             : /*
    2925             :  * quickdie() occurs when signaled SIGQUIT by the postmaster.
    2926             :  *
    2927             :  * Either some backend has bought the farm, or we've been told to shut down
    2928             :  * "immediately"; so we need to stop what we're doing and exit.
    2929             :  */
    2930             : void
    2931           0 : quickdie(SIGNAL_ARGS)
    2932             : {
    2933           0 :     sigaddset(&BlockSig, SIGQUIT);  /* prevent nested calls */
    2934           0 :     sigprocmask(SIG_SETMASK, &BlockSig, NULL);
    2935             : 
    2936             :     /*
    2937             :      * Prevent interrupts while exiting; though we just blocked signals that
    2938             :      * would queue new interrupts, one may have been pending.  We don't want a
    2939             :      * quickdie() downgraded to a mere query cancel.
    2940             :      */
    2941           0 :     HOLD_INTERRUPTS();
    2942             : 
    2943             :     /*
    2944             :      * If we're aborting out of client auth, don't risk trying to send
    2945             :      * anything to the client; we will likely violate the protocol, not to
    2946             :      * mention that we may have interrupted the guts of OpenSSL or some
    2947             :      * authentication library.
    2948             :      */
    2949           0 :     if (ClientAuthInProgress && whereToSendOutput == DestRemote)
    2950           0 :         whereToSendOutput = DestNone;
    2951             : 
    2952             :     /*
    2953             :      * Notify the client before exiting, to give a clue on what happened.
    2954             :      *
    2955             :      * It's dubious to call ereport() from a signal handler.  It is certainly
    2956             :      * not async-signal safe.  But it seems better to try, than to disconnect
    2957             :      * abruptly and leave the client wondering what happened.  It's remotely
    2958             :      * possible that we crash or hang while trying to send the message, but
    2959             :      * receiving a SIGQUIT is a sign that something has already gone badly
    2960             :      * wrong, so there's not much to lose.  Assuming the postmaster is still
    2961             :      * running, it will SIGKILL us soon if we get stuck for some reason.
    2962             :      *
    2963             :      * One thing we can do to make this a tad safer is to clear the error
    2964             :      * context stack, so that context callbacks are not called.  That's a lot
    2965             :      * less code that could be reached here, and the context info is unlikely
    2966             :      * to be very relevant to a SIGQUIT report anyway.
    2967             :      */
    2968           0 :     error_context_stack = NULL;
    2969             : 
    2970             :     /*
    2971             :      * When responding to a postmaster-issued signal, we send the message only
    2972             :      * to the client; sending to the server log just creates log spam, plus
    2973             :      * it's more code that we need to hope will work in a signal handler.
    2974             :      *
    2975             :      * Ideally these should be ereport(FATAL), but then we'd not get control
    2976             :      * back to force the correct type of process exit.
    2977             :      */
    2978           0 :     switch (GetQuitSignalReason())
    2979             :     {
    2980           0 :         case PMQUIT_NOT_SENT:
    2981             :             /* Hmm, SIGQUIT arrived out of the blue */
    2982           0 :             ereport(WARNING,
    2983             :                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
    2984             :                      errmsg("terminating connection because of unexpected SIGQUIT signal")));
    2985           0 :             break;
    2986           0 :         case PMQUIT_FOR_CRASH:
    2987             :             /* A crash-and-restart cycle is in progress */
    2988           0 :             ereport(WARNING_CLIENT_ONLY,
    2989             :                     (errcode(ERRCODE_CRASH_SHUTDOWN),
    2990             :                      errmsg("terminating connection because of crash of another server process"),
    2991             :                      errdetail("The postmaster has commanded this server process to roll back"
    2992             :                                " the current transaction and exit, because another"
    2993             :                                " server process exited abnormally and possibly corrupted"
    2994             :                                " shared memory."),
    2995             :                      errhint("In a moment you should be able to reconnect to the"
    2996             :                              " database and repeat your command.")));
    2997           0 :             break;
    2998           0 :         case PMQUIT_FOR_STOP:
    2999             :             /* Immediate-mode stop */
    3000           0 :             ereport(WARNING_CLIENT_ONLY,
    3001             :                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
    3002             :                      errmsg("terminating connection due to immediate shutdown command")));
    3003           0 :             break;
    3004             :     }
    3005             : 
    3006             :     /*
    3007             :      * We DO NOT want to run proc_exit() or atexit() callbacks -- we're here
    3008             :      * because shared memory may be corrupted, so we don't want to try to
    3009             :      * clean up our transaction.  Just nail the windows shut and get out of
    3010             :      * town.  The callbacks wouldn't be safe to run from a signal handler,
    3011             :      * anyway.
    3012             :      *
    3013             :      * Note we do _exit(2) not _exit(0).  This is to force the postmaster into
    3014             :      * a system reset cycle if someone sends a manual SIGQUIT to a random
    3015             :      * backend.  This is necessary precisely because we don't clean up our
    3016             :      * shared memory state.  (The "dead man switch" mechanism in pmsignal.c
    3017             :      * should ensure the postmaster sees this as a crash, too, but no harm in
    3018             :      * being doubly sure.)
    3019             :      */
    3020           0 :     _exit(2);
    3021             : }
    3022             : 
    3023             : /*
    3024             :  * Shutdown signal from postmaster: abort transaction and exit
    3025             :  * at soonest convenient time
    3026             :  */
    3027             : void
    3028        1706 : die(SIGNAL_ARGS)
    3029             : {
    3030             :     /* Don't joggle the elbow of proc_exit */
    3031        1706 :     if (!proc_exit_inprogress)
    3032             :     {
    3033        1218 :         InterruptPending = true;
    3034        1218 :         ProcDiePending = true;
    3035             :     }
    3036             : 
    3037             :     /* for the cumulative stats system */
    3038        1706 :     pgStatSessionEndCause = DISCONNECT_KILLED;
    3039             : 
    3040             :     /* If we're still here, waken anything waiting on the process latch */
    3041        1706 :     SetLatch(MyLatch);
    3042             : 
    3043             :     /*
    3044             :      * If we're in single user mode, we want to quit immediately - we can't
    3045             :      * rely on latches as they wouldn't work when stdin/stdout is a file.
    3046             :      * Rather ugly, but it's unlikely to be worthwhile to invest much more
    3047             :      * effort just for the benefit of single user mode.
    3048             :      */
    3049        1706 :     if (DoingCommandRead && whereToSendOutput != DestRemote)
    3050           0 :         ProcessInterrupts();
    3051        1706 : }
    3052             : 
    3053             : /*
    3054             :  * Query-cancel signal from postmaster: abort current transaction
    3055             :  * at soonest convenient time
    3056             :  */
    3057             : void
    3058         130 : StatementCancelHandler(SIGNAL_ARGS)
    3059             : {
    3060             :     /*
    3061             :      * Don't joggle the elbow of proc_exit
    3062             :      */
    3063         130 :     if (!proc_exit_inprogress)
    3064             :     {
    3065         130 :         InterruptPending = true;
    3066         130 :         QueryCancelPending = true;
    3067             :     }
    3068             : 
    3069             :     /* If we're still here, waken anything waiting on the process latch */
    3070         130 :     SetLatch(MyLatch);
    3071         130 : }
    3072             : 
    3073             : /* signal handler for floating point exception */
    3074             : void
    3075           0 : FloatExceptionHandler(SIGNAL_ARGS)
    3076             : {
    3077             :     /* We're not returning, so no need to save errno */
    3078           0 :     ereport(ERROR,
    3079             :             (errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
    3080             :              errmsg("floating-point exception"),
    3081             :              errdetail("An invalid floating-point operation was signaled. "
    3082             :                        "This probably means an out-of-range result or an "
    3083             :                        "invalid operation, such as division by zero.")));
    3084             : }
    3085             : 
    3086             : /*
    3087             :  * Tell the next CHECK_FOR_INTERRUPTS() to check for a particular type of
    3088             :  * recovery conflict.  Runs in a SIGUSR1 handler.
    3089             :  */
    3090             : void
    3091          38 : HandleRecoveryConflictInterrupt(ProcSignalReason reason)
    3092             : {
    3093          38 :     RecoveryConflictPendingReasons[reason] = true;
    3094          38 :     RecoveryConflictPending = true;
    3095          38 :     InterruptPending = true;
    3096             :     /* latch will be set by procsignal_sigusr1_handler */
    3097          38 : }
    3098             : 
    3099             : /*
    3100             :  * Check one individual conflict reason.
    3101             :  */
    3102             : static void
    3103          38 : ProcessRecoveryConflictInterrupt(ProcSignalReason reason)
    3104             : {
    3105          38 :     switch (reason)
    3106             :     {
    3107          16 :         case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
    3108             : 
    3109             :             /*
    3110             :              * If we aren't waiting for a lock we can never deadlock.
    3111             :              */
    3112          16 :             if (GetAwaitedLock() == NULL)
    3113          12 :                 return;
    3114             : 
    3115             :             /* Intentional fall through to check wait for pin */
    3116             :             /* FALLTHROUGH */
    3117             : 
    3118             :         case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
    3119             : 
    3120             :             /*
    3121             :              * If PROCSIG_RECOVERY_CONFLICT_BUFFERPIN is requested but we
    3122             :              * aren't blocking the Startup process there is nothing more to
    3123             :              * do.
    3124             :              *
    3125             :              * When PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK is requested,
    3126             :              * if we're waiting for locks and the startup process is not
    3127             :              * waiting for buffer pin (i.e., also waiting for locks), we set
    3128             :              * the flag so that ProcSleep() will check for deadlocks.
    3129             :              */
    3130           6 :             if (!HoldingBufferPinThatDelaysRecovery())
    3131             :             {
    3132           4 :                 if (reason == PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK &&
    3133           2 :                     GetStartupBufferPinWaitBufId() < 0)
    3134           2 :                     CheckDeadLockAlert();
    3135           2 :                 return;
    3136             :             }
    3137             : 
    3138           4 :             MyProc->recoveryConflictPending = true;
    3139             : 
    3140             :             /* Intentional fall through to error handling */
    3141             :             /* FALLTHROUGH */
    3142             : 
    3143          10 :         case PROCSIG_RECOVERY_CONFLICT_LOCK:
    3144             :         case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
    3145             :         case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
    3146             : 
    3147             :             /*
    3148             :              * If we aren't in a transaction any longer then ignore.
    3149             :              */
    3150          10 :             if (!IsTransactionOrTransactionBlock())
    3151           0 :                 return;
    3152             : 
    3153             :             /* FALLTHROUGH */
    3154             : 
    3155             :         case PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT:
    3156             : 
    3157             :             /*
    3158             :              * If we're not in a subtransaction then we are OK to throw an
    3159             :              * ERROR to resolve the conflict.  Otherwise drop through to the
    3160             :              * FATAL case.
    3161             :              *
    3162             :              * PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT is a special case that
    3163             :              * always throws an ERROR (ie never promotes to FATAL), though it
    3164             :              * still has to respect QueryCancelHoldoffCount, so it shares this
    3165             :              * code path.  Logical decoding slots are only acquired while
    3166             :              * performing logical decoding.  During logical decoding no user
    3167             :              * controlled code is run.  During [sub]transaction abort, the
    3168             :              * slot is released.  Therefore user controlled code cannot
    3169             :              * intercept an error before the replication slot is released.
    3170             :              *
    3171             :              * XXX other times that we can throw just an ERROR *may* be
    3172             :              * PROCSIG_RECOVERY_CONFLICT_LOCK if no locks are held in parent
    3173             :              * transactions
    3174             :              *
    3175             :              * PROCSIG_RECOVERY_CONFLICT_SNAPSHOT if no snapshots are held by
    3176             :              * parent transactions and the transaction is not
    3177             :              * transaction-snapshot mode
    3178             :              *
    3179             :              * PROCSIG_RECOVERY_CONFLICT_TABLESPACE if no temp files or
    3180             :              * cursors open in parent transactions
    3181             :              */
    3182          20 :             if (reason == PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT ||
    3183          10 :                 !IsSubTransaction())
    3184             :             {
    3185             :                 /*
    3186             :                  * If we already aborted then we no longer need to cancel.  We
    3187             :                  * do this here since we do not wish to ignore aborted
    3188             :                  * subtransactions, which must cause FATAL, currently.
    3189             :                  */
    3190          20 :                 if (IsAbortedTransactionBlockState())
    3191           0 :                     return;
    3192             : 
    3193             :                 /*
    3194             :                  * If a recovery conflict happens while we are waiting for
    3195             :                  * input from the client, the client is presumably just
    3196             :                  * sitting idle in a transaction, preventing recovery from
    3197             :                  * making progress.  We'll drop through to the FATAL case
    3198             :                  * below to dislodge it, in that case.
    3199             :                  */
    3200          20 :                 if (!DoingCommandRead)
    3201             :                 {
    3202             :                     /* Avoid losing sync in the FE/BE protocol. */
    3203          12 :                     if (QueryCancelHoldoffCount != 0)
    3204             :                     {
    3205             :                         /*
    3206             :                          * Re-arm and defer this interrupt until later.  See
    3207             :                          * similar code in ProcessInterrupts().
    3208             :                          */
    3209           0 :                         RecoveryConflictPendingReasons[reason] = true;
    3210           0 :                         RecoveryConflictPending = true;
    3211           0 :                         InterruptPending = true;
    3212           0 :                         return;
    3213             :                     }
    3214             : 
    3215             :                     /*
    3216             :                      * We are cleared to throw an ERROR.  Either it's the
    3217             :                      * logical slot case, or we have a top-level transaction
    3218             :                      * that we can abort and a conflict that isn't inherently
    3219             :                      * non-retryable.
    3220             :                      */
    3221          12 :                     LockErrorCleanup();
    3222          12 :                     pgstat_report_recovery_conflict(reason);
    3223          12 :                     ereport(ERROR,
    3224             :                             (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
    3225             :                              errmsg("canceling statement due to conflict with recovery"),
    3226             :                              errdetail_recovery_conflict(reason)));
    3227             :                     break;
    3228             :                 }
    3229             :             }
    3230             : 
    3231             :             /* Intentional fall through to session cancel */
    3232             :             /* FALLTHROUGH */
    3233             : 
    3234             :         case PROCSIG_RECOVERY_CONFLICT_DATABASE:
    3235             : 
    3236             :             /*
    3237             :              * Retrying is not possible because the database is dropped, or we
    3238             :              * decided above that we couldn't resolve the conflict with an
    3239             :              * ERROR and fell through.  Terminate the session.
    3240             :              */
    3241          12 :             pgstat_report_recovery_conflict(reason);
    3242          12 :             ereport(FATAL,
    3243             :                     (errcode(reason == PROCSIG_RECOVERY_CONFLICT_DATABASE ?
    3244             :                              ERRCODE_DATABASE_DROPPED :
    3245             :                              ERRCODE_T_R_SERIALIZATION_FAILURE),
    3246             :                      errmsg("terminating connection due to conflict with recovery"),
    3247             :                      errdetail_recovery_conflict(reason),
    3248             :                      errhint("In a moment you should be able to reconnect to the"
    3249             :                              " database and repeat your command.")));
    3250             :             break;
    3251             : 
    3252           0 :         default:
    3253           0 :             elog(FATAL, "unrecognized conflict mode: %d", (int) reason);
    3254             :     }
    3255             : }
    3256             : 
    3257             : /*
    3258             :  * Check each possible recovery conflict reason.
    3259             :  */
    3260             : static void
    3261          38 : ProcessRecoveryConflictInterrupts(void)
    3262             : {
    3263             :     /*
    3264             :      * We don't need to worry about joggling the elbow of proc_exit, because
    3265             :      * proc_exit_prepare() holds interrupts, so ProcessInterrupts() won't call
    3266             :      * us.
    3267             :      */
    3268             :     Assert(!proc_exit_inprogress);
    3269             :     Assert(InterruptHoldoffCount == 0);
    3270             :     Assert(RecoveryConflictPending);
    3271             : 
    3272          38 :     RecoveryConflictPending = false;
    3273             : 
    3274         210 :     for (ProcSignalReason reason = PROCSIG_RECOVERY_CONFLICT_FIRST;
    3275             :          reason <= PROCSIG_RECOVERY_CONFLICT_LAST;
    3276         172 :          reason++)
    3277             :     {
    3278         196 :         if (RecoveryConflictPendingReasons[reason])
    3279             :         {
    3280          38 :             RecoveryConflictPendingReasons[reason] = false;
    3281          38 :             ProcessRecoveryConflictInterrupt(reason);
    3282             :         }
    3283             :     }
    3284          14 : }
    3285             : 
    3286             : /*
    3287             :  * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro
    3288             :  *
    3289             :  * If an interrupt condition is pending, and it's safe to service it,
    3290             :  * then clear the flag and accept the interrupt.  Called only when
    3291             :  * InterruptPending is true.
    3292             :  *
    3293             :  * Note: if INTERRUPTS_CAN_BE_PROCESSED() is true, then ProcessInterrupts
    3294             :  * is guaranteed to clear the InterruptPending flag before returning.
    3295             :  * (This is not the same as guaranteeing that it's still clear when we
    3296             :  * return; another interrupt could have arrived.  But we promise that
    3297             :  * any pre-existing one will have been serviced.)
    3298             :  */
    3299             : void
    3300        7074 : ProcessInterrupts(void)
    3301             : {
    3302             :     /* OK to accept any interrupts now? */
    3303        7074 :     if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
    3304        1184 :         return;
    3305        5890 :     InterruptPending = false;
    3306             : 
    3307        5890 :     if (ProcDiePending)
    3308             :     {
    3309        1210 :         ProcDiePending = false;
    3310        1210 :         QueryCancelPending = false; /* ProcDie trumps QueryCancel */
    3311        1210 :         LockErrorCleanup();
    3312             :         /* As in quickdie, don't risk sending to client during auth */
    3313        1210 :         if (ClientAuthInProgress && whereToSendOutput == DestRemote)
    3314           0 :             whereToSendOutput = DestNone;
    3315        1210 :         if (ClientAuthInProgress)
    3316           0 :             ereport(FATAL,
    3317             :                     (errcode(ERRCODE_QUERY_CANCELED),
    3318             :                      errmsg("canceling authentication due to timeout")));
    3319        1210 :         else if (AmAutoVacuumWorkerProcess())
    3320           2 :             ereport(FATAL,
    3321             :                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
    3322             :                      errmsg("terminating autovacuum process due to administrator command")));
    3323        1208 :         else if (IsLogicalWorker())
    3324         204 :             ereport(FATAL,
    3325             :                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
    3326             :                      errmsg("terminating logical replication worker due to administrator command")));
    3327        1004 :         else if (IsLogicalLauncher())
    3328             :         {
    3329         792 :             ereport(DEBUG1,
    3330             :                     (errmsg_internal("logical replication launcher shutting down")));
    3331             : 
    3332             :             /*
    3333             :              * The logical replication launcher can be stopped at any time.
    3334             :              * Use exit status 1 so the background worker is restarted.
    3335             :              */
    3336         792 :             proc_exit(1);
    3337             :         }
    3338         212 :         else if (AmWalReceiverProcess())
    3339         160 :             ereport(FATAL,
    3340             :                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
    3341             :                      errmsg("terminating walreceiver process due to administrator command")));
    3342          52 :         else if (AmBackgroundWorkerProcess())
    3343           2 :             ereport(FATAL,
    3344             :                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
    3345             :                      errmsg("terminating background worker \"%s\" due to administrator command",
    3346             :                             MyBgworkerEntry->bgw_type)));
    3347          50 :         else if (AmIoWorkerProcess())
    3348             :         {
    3349           8 :             ereport(DEBUG1,
    3350             :                     (errmsg_internal("io worker shutting down due to administrator command")));
    3351             : 
    3352           8 :             proc_exit(0);
    3353             :         }
    3354             :         else
    3355          42 :             ereport(FATAL,
    3356             :                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
    3357             :                      errmsg("terminating connection due to administrator command")));
    3358             :     }
    3359             : 
    3360        4680 :     if (CheckClientConnectionPending)
    3361             :     {
    3362           0 :         CheckClientConnectionPending = false;
    3363             : 
    3364             :         /*
    3365             :          * Check for lost connection and re-arm, if still configured, but not
    3366             :          * if we've arrived back at DoingCommandRead state.  We don't want to
    3367             :          * wake up idle sessions, and they already know how to detect lost
    3368             :          * connections.
    3369             :          */
    3370           0 :         if (!DoingCommandRead && client_connection_check_interval > 0)
    3371             :         {
    3372           0 :             if (!pq_check_connection())
    3373           0 :                 ClientConnectionLost = true;
    3374             :             else
    3375           0 :                 enable_timeout_after(CLIENT_CONNECTION_CHECK_TIMEOUT,
    3376             :                                      client_connection_check_interval);
    3377             :         }
    3378             :     }
    3379             : 
    3380        4680 :     if (ClientConnectionLost)
    3381             :     {
    3382          56 :         QueryCancelPending = false; /* lost connection trumps QueryCancel */
    3383          56 :         LockErrorCleanup();
    3384             :         /* don't send to client, we already know the connection to be dead. */
    3385          56 :         whereToSendOutput = DestNone;
    3386          56 :         ereport(FATAL,
    3387             :                 (errcode(ERRCODE_CONNECTION_FAILURE),
    3388             :                  errmsg("connection to client lost")));
    3389             :     }
    3390             : 
    3391             :     /*
    3392             :      * Don't allow query cancel interrupts while reading input from the
    3393             :      * client, because we might lose sync in the FE/BE protocol.  (Die
    3394             :      * interrupts are OK, because we won't read any further messages from the
    3395             :      * client in that case.)
    3396             :      *
    3397             :      * See similar logic in ProcessRecoveryConflictInterrupts().
    3398             :      */
    3399        4624 :     if (QueryCancelPending && QueryCancelHoldoffCount != 0)
    3400             :     {
    3401             :         /*
    3402             :          * Re-arm InterruptPending so that we process the cancel request as
    3403             :          * soon as we're done reading the message.  (XXX this is seriously
    3404             :          * ugly: it complicates INTERRUPTS_CAN_BE_PROCESSED(), and it means we
    3405             :          * can't use that macro directly as the initial test in this function,
    3406             :          * meaning that this code also creates opportunities for other bugs to
    3407             :          * appear.)
    3408             :          */
    3409          24 :         InterruptPending = true;
    3410             :     }
    3411        4600 :     else if (QueryCancelPending)
    3412             :     {
    3413             :         bool        lock_timeout_occurred;
    3414             :         bool        stmt_timeout_occurred;
    3415             : 
    3416         110 :         QueryCancelPending = false;
    3417             : 
    3418             :         /*
    3419             :          * If LOCK_TIMEOUT and STATEMENT_TIMEOUT indicators are both set, we
    3420             :          * need to clear both, so always fetch both.
    3421             :          */
    3422         110 :         lock_timeout_occurred = get_timeout_indicator(LOCK_TIMEOUT, true);
    3423         110 :         stmt_timeout_occurred = get_timeout_indicator(STATEMENT_TIMEOUT, true);
    3424             : 
    3425             :         /*
    3426             :          * If both were set, we want to report whichever timeout completed
    3427             :          * earlier; this ensures consistent behavior if the machine is slow
    3428             :          * enough that the second timeout triggers before we get here.  A tie
    3429             :          * is arbitrarily broken in favor of reporting a lock timeout.
    3430             :          */
    3431         110 :         if (lock_timeout_occurred && stmt_timeout_occurred &&
    3432           0 :             get_timeout_finish_time(STATEMENT_TIMEOUT) < get_timeout_finish_time(LOCK_TIMEOUT))
    3433           0 :             lock_timeout_occurred = false;  /* report stmt timeout */
    3434             : 
    3435         110 :         if (lock_timeout_occurred)
    3436             :         {
    3437           8 :             LockErrorCleanup();
    3438           8 :             ereport(ERROR,
    3439             :                     (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
    3440             :                      errmsg("canceling statement due to lock timeout")));
    3441             :         }
    3442         102 :         if (stmt_timeout_occurred)
    3443             :         {
    3444          12 :             LockErrorCleanup();
    3445          12 :             ereport(ERROR,
    3446             :                     (errcode(ERRCODE_QUERY_CANCELED),
    3447             :                      errmsg("canceling statement due to statement timeout")));
    3448             :         }
    3449          90 :         if (AmAutoVacuumWorkerProcess())
    3450             :         {
    3451           0 :             LockErrorCleanup();
    3452           0 :             ereport(ERROR,
    3453             :                     (errcode(ERRCODE_QUERY_CANCELED),
    3454             :                      errmsg("canceling autovacuum task")));
    3455             :         }
    3456             : 
    3457             :         /*
    3458             :          * If we are reading a command from the client, just ignore the cancel
    3459             :          * request --- sending an extra error message won't accomplish
    3460             :          * anything.  Otherwise, go ahead and throw the error.
    3461             :          */
    3462          90 :         if (!DoingCommandRead)
    3463             :         {
    3464          80 :             LockErrorCleanup();
    3465          80 :             ereport(ERROR,
    3466             :                     (errcode(ERRCODE_QUERY_CANCELED),
    3467             :                      errmsg("canceling statement due to user request")));
    3468             :         }
    3469             :     }
    3470             : 
    3471        4524 :     if (RecoveryConflictPending)
    3472          38 :         ProcessRecoveryConflictInterrupts();
    3473             : 
    3474        4500 :     if (IdleInTransactionSessionTimeoutPending)
    3475             :     {
    3476             :         /*
    3477             :          * If the GUC has been reset to zero, ignore the signal.  This is
    3478             :          * important because the GUC update itself won't disable any pending
    3479             :          * interrupt.  We need to unset the flag before the injection point,
    3480             :          * otherwise we could loop in interrupts checking.
    3481             :          */
    3482           2 :         IdleInTransactionSessionTimeoutPending = false;
    3483           2 :         if (IdleInTransactionSessionTimeout > 0)
    3484             :         {
    3485           2 :             INJECTION_POINT("idle-in-transaction-session-timeout");
    3486           2 :             ereport(FATAL,
    3487             :                     (errcode(ERRCODE_IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
    3488             :                      errmsg("terminating connection due to idle-in-transaction timeout")));
    3489             :         }
    3490             :     }
    3491             : 
    3492        4498 :     if (TransactionTimeoutPending)
    3493             :     {
    3494             :         /* As above, ignore the signal if the GUC has been reset to zero. */
    3495           2 :         TransactionTimeoutPending = false;
    3496           2 :         if (TransactionTimeout > 0)
    3497             :         {
    3498           2 :             INJECTION_POINT("transaction-timeout");
    3499           2 :             ereport(FATAL,
    3500             :                     (errcode(ERRCODE_TRANSACTION_TIMEOUT),
    3501             :                      errmsg("terminating connection due to transaction timeout")));
    3502             :         }
    3503             :     }
    3504             : 
    3505        4496 :     if (IdleSessionTimeoutPending)
    3506             :     {
    3507             :         /* As above, ignore the signal if the GUC has been reset to zero. */
    3508           0 :         IdleSessionTimeoutPending = false;
    3509           0 :         if (IdleSessionTimeout > 0)
    3510             :         {
    3511           0 :             INJECTION_POINT("idle-session-timeout");
    3512           0 :             ereport(FATAL,
    3513             :                     (errcode(ERRCODE_IDLE_SESSION_TIMEOUT),
    3514             :                      errmsg("terminating connection due to idle-session timeout")));
    3515             :         }
    3516             :     }
    3517             : 
    3518             :     /*
    3519             :      * If there are pending stats updates and we currently are truly idle
    3520             :      * (matching the conditions in PostgresMain(), report stats now.
    3521             :      */
    3522        4496 :     if (IdleStatsUpdateTimeoutPending &&
    3523          26 :         DoingCommandRead && !IsTransactionOrTransactionBlock())
    3524             :     {
    3525           6 :         IdleStatsUpdateTimeoutPending = false;
    3526           6 :         pgstat_report_stat(true);
    3527             :     }
    3528             : 
    3529        4496 :     if (ProcSignalBarrierPending)
    3530         766 :         ProcessProcSignalBarrier();
    3531             : 
    3532        4496 :     if (ParallelMessagePending)
    3533        3498 :         ProcessParallelMessages();
    3534             : 
    3535        4484 :     if (LogMemoryContextPending)
    3536          16 :         ProcessLogMemoryContextInterrupt();
    3537             : 
    3538        4484 :     if (PublishMemoryContextPending)
    3539           6 :         ProcessGetMemoryContextInterrupt();
    3540             : 
    3541        4484 :     if (ParallelApplyMessagePending)
    3542          12 :         ProcessParallelApplyMessages();
    3543             : }
    3544             : 
    3545             : /*
    3546             :  * GUC check_hook for client_connection_check_interval
    3547             :  */
    3548             : bool
    3549        2168 : check_client_connection_check_interval(int *newval, void **extra, GucSource source)
    3550             : {
    3551        2168 :     if (!WaitEventSetCanReportClosed() && *newval != 0)
    3552             :     {
    3553           0 :         GUC_check_errdetail("\"client_connection_check_interval\" must be set to 0 on this platform.");
    3554           0 :         return false;
    3555             :     }
    3556        2168 :     return true;
    3557             : }
    3558             : 
    3559             : /*
    3560             :  * GUC check_hook for log_parser_stats, log_planner_stats, log_executor_stats
    3561             :  *
    3562             :  * This function and check_log_stats interact to prevent their variables from
    3563             :  * being set in a disallowed combination.  This is a hack that doesn't really
    3564             :  * work right; for example it might fail while applying pg_db_role_setting
    3565             :  * values even though the final state would have been acceptable.  However,
    3566             :  * since these variables are legacy settings with little production usage,
    3567             :  * we tolerate that.
    3568             :  */
    3569             : bool
    3570        6504 : check_stage_log_stats(bool *newval, void **extra, GucSource source)
    3571             : {
    3572        6504 :     if (*newval && log_statement_stats)
    3573             :     {
    3574           0 :         GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
    3575           0 :         return false;
    3576             :     }
    3577        6504 :     return true;
    3578             : }
    3579             : 
    3580             : /*
    3581             :  * GUC check_hook for log_statement_stats
    3582             :  */
    3583             : bool
    3584        2168 : check_log_stats(bool *newval, void **extra, GucSource source)
    3585             : {
    3586        2168 :     if (*newval &&
    3587           0 :         (log_parser_stats || log_planner_stats || log_executor_stats))
    3588             :     {
    3589           0 :         GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
    3590             :                             "\"log_parser_stats\", \"log_planner_stats\", "
    3591             :                             "or \"log_executor_stats\" is true.");
    3592           0 :         return false;
    3593             :     }
    3594        2168 :     return true;
    3595             : }
    3596             : 
    3597             : /* GUC assign hook for transaction_timeout */
    3598             : void
    3599        6070 : assign_transaction_timeout(int newval, void *extra)
    3600             : {
    3601        6070 :     if (IsTransactionState())
    3602             :     {
    3603             :         /*
    3604             :          * If transaction_timeout GUC has changed within the transaction block
    3605             :          * enable or disable the timer correspondingly.
    3606             :          */
    3607         782 :         if (newval > 0 && !get_timeout_active(TRANSACTION_TIMEOUT))
    3608           2 :             enable_timeout_after(TRANSACTION_TIMEOUT, newval);
    3609         780 :         else if (newval <= 0 && get_timeout_active(TRANSACTION_TIMEOUT))
    3610           0 :             disable_timeout(TRANSACTION_TIMEOUT, false);
    3611             :     }
    3612        6070 : }
    3613             : 
    3614             : /*
    3615             :  * GUC check_hook for restrict_nonsystem_relation_kind
    3616             :  */
    3617             : bool
    3618        2712 : check_restrict_nonsystem_relation_kind(char **newval, void **extra, GucSource source)
    3619             : {
    3620             :     char       *rawstring;
    3621             :     List       *elemlist;
    3622             :     ListCell   *l;
    3623        2712 :     int         flags = 0;
    3624             : 
    3625             :     /* Need a modifiable copy of string */
    3626        2712 :     rawstring = pstrdup(*newval);
    3627             : 
    3628        2712 :     if (!SplitIdentifierString(rawstring, ',', &elemlist))
    3629             :     {
    3630             :         /* syntax error in list */
    3631           0 :         GUC_check_errdetail("List syntax is invalid.");
    3632           0 :         pfree(rawstring);
    3633           0 :         list_free(elemlist);
    3634           0 :         return false;
    3635             :     }
    3636             : 
    3637        3790 :     foreach(l, elemlist)
    3638             :     {
    3639        1078 :         char       *tok = (char *) lfirst(l);
    3640             : 
    3641        1078 :         if (pg_strcasecmp(tok, "view") == 0)
    3642         542 :             flags |= RESTRICT_RELKIND_VIEW;
    3643         536 :         else if (pg_strcasecmp(tok, "foreign-table") == 0)
    3644         536 :             flags |= RESTRICT_RELKIND_FOREIGN_TABLE;
    3645             :         else
    3646             :         {
    3647           0 :             GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
    3648           0 :             pfree(rawstring);
    3649           0 :             list_free(elemlist);
    3650           0 :             return false;
    3651             :         }
    3652             :     }
    3653             : 
    3654        2712 :     pfree(rawstring);
    3655        2712 :     list_free(elemlist);
    3656             : 
    3657             :     /* Save the flags in *extra, for use by the assign function */
    3658        2712 :     *extra = guc_malloc(LOG, sizeof(int));
    3659        2712 :     if (!*extra)
    3660           0 :         return false;
    3661        2712 :     *((int *) *extra) = flags;
    3662             : 
    3663        2712 :     return true;
    3664             : }
    3665             : 
    3666             : /*
    3667             :  * GUC assign_hook for restrict_nonsystem_relation_kind
    3668             :  */
    3669             : void
    3670        2722 : assign_restrict_nonsystem_relation_kind(const char *newval, void *extra)
    3671             : {
    3672        2722 :     int        *flags = (int *) extra;
    3673             : 
    3674        2722 :     restrict_nonsystem_relation_kind = *flags;
    3675        2722 : }
    3676             : 
    3677             : /*
    3678             :  * set_debug_options --- apply "-d N" command line option
    3679             :  *
    3680             :  * -d is not quite the same as setting log_min_messages because it enables
    3681             :  * other output options.
    3682             :  */
    3683             : void
    3684           0 : set_debug_options(int debug_flag, GucContext context, GucSource source)
    3685             : {
    3686           0 :     if (debug_flag > 0)
    3687             :     {
    3688             :         char        debugstr[64];
    3689             : 
    3690           0 :         sprintf(debugstr, "debug%d", debug_flag);
    3691           0 :         SetConfigOption("log_min_messages", debugstr, context, source);
    3692             :     }
    3693             :     else
    3694           0 :         SetConfigOption("log_min_messages", "notice", context, source);
    3695             : 
    3696           0 :     if (debug_flag >= 1 && context == PGC_POSTMASTER)
    3697             :     {
    3698           0 :         SetConfigOption("log_connections", "true", context, source);
    3699           0 :         SetConfigOption("log_disconnections", "true", context, source);
    3700             :     }
    3701           0 :     if (debug_flag >= 2)
    3702           0 :         SetConfigOption("log_statement", "all", context, source);
    3703           0 :     if (debug_flag >= 3)
    3704           0 :         SetConfigOption("debug_print_parse", "true", context, source);
    3705           0 :     if (debug_flag >= 4)
    3706           0 :         SetConfigOption("debug_print_plan", "true", context, source);
    3707           0 :     if (debug_flag >= 5)
    3708           0 :         SetConfigOption("debug_print_rewritten", "true", context, source);
    3709           0 : }
    3710             : 
    3711             : 
    3712             : bool
    3713           0 : set_plan_disabling_options(const char *arg, GucContext context, GucSource source)
    3714             : {
    3715           0 :     const char *tmp = NULL;
    3716             : 
    3717           0 :     switch (arg[0])
    3718             :     {
    3719           0 :         case 's':               /* seqscan */
    3720           0 :             tmp = "enable_seqscan";
    3721           0 :             break;
    3722           0 :         case 'i':               /* indexscan */
    3723           0 :             tmp = "enable_indexscan";
    3724           0 :             break;
    3725           0 :         case 'o':               /* indexonlyscan */
    3726           0 :             tmp = "enable_indexonlyscan";
    3727           0 :             break;
    3728           0 :         case 'b':               /* bitmapscan */
    3729           0 :             tmp = "enable_bitmapscan";
    3730           0 :             break;
    3731           0 :         case 't':               /* tidscan */
    3732           0 :             tmp = "enable_tidscan";
    3733           0 :             break;
    3734           0 :         case 'n':               /* nestloop */
    3735           0 :             tmp = "enable_nestloop";
    3736           0 :             break;
    3737           0 :         case 'm':               /* mergejoin */
    3738           0 :             tmp = "enable_mergejoin";
    3739           0 :             break;
    3740           0 :         case 'h':               /* hashjoin */
    3741           0 :             tmp = "enable_hashjoin";
    3742           0 :             break;
    3743             :     }
    3744           0 :     if (tmp)
    3745             :     {
    3746           0 :         SetConfigOption(tmp, "false", context, source);
    3747           0 :         return true;
    3748             :     }
    3749             :     else
    3750           0 :         return false;
    3751             : }
    3752             : 
    3753             : 
    3754             : const char *
    3755           0 : get_stats_option_name(const char *arg)
    3756             : {
    3757           0 :     switch (arg[0])
    3758             :     {
    3759           0 :         case 'p':
    3760           0 :             if (optarg[1] == 'a')   /* "parser" */
    3761           0 :                 return "log_parser_stats";
    3762           0 :             else if (optarg[1] == 'l')  /* "planner" */
    3763           0 :                 return "log_planner_stats";
    3764           0 :             break;
    3765             : 
    3766           0 :         case 'e':               /* "executor" */
    3767           0 :             return "log_executor_stats";
    3768             :             break;
    3769             :     }
    3770             : 
    3771           0 :     return NULL;
    3772             : }
    3773             : 
    3774             : 
    3775             : /* ----------------------------------------------------------------
    3776             :  * process_postgres_switches
    3777             :  *     Parse command line arguments for backends
    3778             :  *
    3779             :  * This is called twice, once for the "secure" options coming from the
    3780             :  * postmaster or command line, and once for the "insecure" options coming
    3781             :  * from the client's startup packet.  The latter have the same syntax but
    3782             :  * may be restricted in what they can do.
    3783             :  *
    3784             :  * argv[0] is ignored in either case (it's assumed to be the program name).
    3785             :  *
    3786             :  * ctx is PGC_POSTMASTER for secure options, PGC_BACKEND for insecure options
    3787             :  * coming from the client, or PGC_SU_BACKEND for insecure options coming from
    3788             :  * a superuser client.
    3789             :  *
    3790             :  * If a database name is present in the command line arguments, it's
    3791             :  * returned into *dbname (this is allowed only if *dbname is initially NULL).
    3792             :  * ----------------------------------------------------------------
    3793             :  */
    3794             : void
    3795        7214 : process_postgres_switches(int argc, char *argv[], GucContext ctx,
    3796             :                           const char **dbname)
    3797             : {
    3798        7214 :     bool        secure = (ctx == PGC_POSTMASTER);
    3799        7214 :     int         errs = 0;
    3800             :     GucSource   gucsource;
    3801             :     int         flag;
    3802             : 
    3803        7214 :     if (secure)
    3804             :     {
    3805         120 :         gucsource = PGC_S_ARGV; /* switches came from command line */
    3806             : 
    3807             :         /* Ignore the initial --single argument, if present */
    3808         120 :         if (argc > 1 && strcmp(argv[1], "--single") == 0)
    3809             :         {
    3810         120 :             argv++;
    3811         120 :             argc--;
    3812             :         }
    3813             :     }
    3814             :     else
    3815             :     {
    3816        7094 :         gucsource = PGC_S_CLIENT;   /* switches came from client */
    3817             :     }
    3818             : 
    3819             : #ifdef HAVE_INT_OPTERR
    3820             : 
    3821             :     /*
    3822             :      * Turn this off because it's either printed to stderr and not the log
    3823             :      * where we'd want it, or argv[0] is now "--single", which would make for
    3824             :      * a weird error message.  We print our own error message below.
    3825             :      */
    3826        7214 :     opterr = 0;
    3827             : #endif
    3828             : 
    3829             :     /*
    3830             :      * Parse command-line options.  CAUTION: keep this in sync with
    3831             :      * postmaster/postmaster.c (the option sets should not conflict) and with
    3832             :      * the common help() function in main/main.c.
    3833             :      */
    3834       17328 :     while ((flag = getopt(argc, argv, "B:bC:c:D:d:EeFf:h:ijk:lN:nOPp:r:S:sTt:v:W:-:")) != -1)
    3835             :     {
    3836       10114 :         switch (flag)
    3837             :         {
    3838           0 :             case 'B':
    3839           0 :                 SetConfigOption("shared_buffers", optarg, ctx, gucsource);
    3840           0 :                 break;
    3841             : 
    3842           0 :             case 'b':
    3843             :                 /* Undocumented flag used for binary upgrades */
    3844           0 :                 if (secure)
    3845           0 :                     IsBinaryUpgrade = true;
    3846           0 :                 break;
    3847             : 
    3848           0 :             case 'C':
    3849             :                 /* ignored for consistency with the postmaster */
    3850           0 :                 break;
    3851             : 
    3852         134 :             case '-':
    3853             : 
    3854             :                 /*
    3855             :                  * Error if the user misplaced a special must-be-first option
    3856             :                  * for dispatching to a subprogram.  parse_dispatch_option()
    3857             :                  * returns DISPATCH_POSTMASTER if it doesn't find a match, so
    3858             :                  * error for anything else.
    3859             :                  */
    3860         134 :                 if (parse_dispatch_option(optarg) != DISPATCH_POSTMASTER)
    3861           0 :                     ereport(ERROR,
    3862             :                             (errcode(ERRCODE_SYNTAX_ERROR),
    3863             :                              errmsg("--%s must be first argument", optarg)));
    3864             : 
    3865             :                 /* FALLTHROUGH */
    3866             :             case 'c':
    3867             :                 {
    3868             :                     char       *name,
    3869             :                                *value;
    3870             : 
    3871        9778 :                     ParseLongOption(optarg, &name, &value);
    3872        9778 :                     if (!value)
    3873             :                     {
    3874           0 :                         if (flag == '-')
    3875           0 :                             ereport(ERROR,
    3876             :                                     (errcode(ERRCODE_SYNTAX_ERROR),
    3877             :                                      errmsg("--%s requires a value",
    3878             :                                             optarg)));
    3879             :                         else
    3880           0 :                             ereport(ERROR,
    3881             :                                     (errcode(ERRCODE_SYNTAX_ERROR),
    3882             :                                      errmsg("-c %s requires a value",
    3883             :                                             optarg)));
    3884             :                     }
    3885        9778 :                     SetConfigOption(name, value, ctx, gucsource);
    3886        9778 :                     pfree(name);
    3887        9778 :                     pfree(value);
    3888        9778 :                     break;
    3889             :                 }
    3890             : 
    3891          22 :             case 'D':
    3892          22 :                 if (secure)
    3893          22 :                     userDoption = strdup(optarg);
    3894          22 :                 break;
    3895             : 
    3896           0 :             case 'd':
    3897           0 :                 set_debug_options(atoi(optarg), ctx, gucsource);
    3898           0 :                 break;
    3899             : 
    3900           0 :             case 'E':
    3901           0 :                 if (secure)
    3902           0 :                     EchoQuery = true;
    3903           0 :                 break;
    3904             : 
    3905           0 :             case 'e':
    3906           0 :                 SetConfigOption("datestyle", "euro", ctx, gucsource);
    3907           0 :                 break;
    3908             : 
    3909         118 :             case 'F':
    3910         118 :                 SetConfigOption("fsync", "false", ctx, gucsource);
    3911         118 :                 break;
    3912             : 
    3913           0 :             case 'f':
    3914           0 :                 if (!set_plan_disabling_options(optarg, ctx, gucsource))
    3915           0 :                     errs++;
    3916           0 :                 break;
    3917             : 
    3918           0 :             case 'h':
    3919           0 :                 SetConfigOption("listen_addresses", optarg, ctx, gucsource);
    3920           0 :                 break;
    3921             : 
    3922           0 :             case 'i':
    3923           0 :                 SetConfigOption("listen_addresses", "*", ctx, gucsource);
    3924           0 :                 break;
    3925             : 
    3926          98 :             case 'j':
    3927          98 :                 if (secure)
    3928          98 :                     UseSemiNewlineNewline = true;
    3929          98 :                 break;
    3930             : 
    3931           0 :             case 'k':
    3932           0 :                 SetConfigOption("unix_socket_directories", optarg, ctx, gucsource);
    3933           0 :                 break;
    3934             : 
    3935           0 :             case 'l':
    3936           0 :                 SetConfigOption("ssl", "true", ctx, gucsource);
    3937           0 :                 break;
    3938             : 
    3939           0 :             case 'N':
    3940           0 :                 SetConfigOption("max_connections", optarg, ctx, gucsource);
    3941           0 :                 break;
    3942             : 
    3943           0 :             case 'n':
    3944             :                 /* ignored for consistency with postmaster */
    3945           0 :                 break;
    3946             : 
    3947          98 :             case 'O':
    3948          98 :                 SetConfigOption("allow_system_table_mods", "true", ctx, gucsource);
    3949          98 :                 break;
    3950             : 
    3951           0 :             case 'P':
    3952           0 :                 SetConfigOption("ignore_system_indexes", "true", ctx, gucsource);
    3953           0 :                 break;
    3954             : 
    3955           0 :             case 'p':
    3956           0 :                 SetConfigOption("port", optarg, ctx, gucsource);
    3957           0 :                 break;
    3958             : 
    3959           0 :             case 'r':
    3960             :                 /* send output (stdout and stderr) to the given file */
    3961           0 :                 if (secure)
    3962           0 :                     strlcpy(OutputFileName, optarg, MAXPGPATH);
    3963           0 :                 break;
    3964             : 
    3965           0 :             case 'S':
    3966           0 :                 SetConfigOption("work_mem", optarg, ctx, gucsource);
    3967           0 :                 break;
    3968             : 
    3969           0 :             case 's':
    3970           0 :                 SetConfigOption("log_statement_stats", "true", ctx, gucsource);
    3971           0 :                 break;
    3972             : 
    3973           0 :             case 'T':
    3974             :                 /* ignored for consistency with the postmaster */
    3975           0 :                 break;
    3976             : 
    3977           0 :             case 't':
    3978             :                 {
    3979           0 :                     const char *tmp = get_stats_option_name(optarg);
    3980             : 
    3981           0 :                     if (tmp)
    3982           0 :                         SetConfigOption(tmp, "true", ctx, gucsource);
    3983             :                     else
    3984           0 :                         errs++;
    3985           0 :                     break;
    3986             :                 }
    3987             : 
    3988           0 :             case 'v':
    3989             : 
    3990             :                 /*
    3991             :                  * -v is no longer used in normal operation, since
    3992             :                  * FrontendProtocol is already set before we get here. We keep
    3993             :                  * the switch only for possible use in standalone operation,
    3994             :                  * in case we ever support using normal FE/BE protocol with a
    3995             :                  * standalone backend.
    3996             :                  */
    3997           0 :                 if (secure)
    3998           0 :                     FrontendProtocol = (ProtocolVersion) atoi(optarg);
    3999           0 :                 break;
    4000             : 
    4001           0 :             case 'W':
    4002           0 :                 SetConfigOption("post_auth_delay", optarg, ctx, gucsource);
    4003           0 :                 break;
    4004             : 
    4005           0 :             default:
    4006           0 :                 errs++;
    4007           0 :                 break;
    4008             :         }
    4009             : 
    4010       10114 :         if (errs)
    4011           0 :             break;
    4012             :     }
    4013             : 
    4014             :     /*
    4015             :      * Optional database name should be there only if *dbname is NULL.
    4016             :      */
    4017        7214 :     if (!errs && dbname && *dbname == NULL && argc - optind >= 1)
    4018         120 :         *dbname = strdup(argv[optind++]);
    4019             : 
    4020        7214 :     if (errs || argc != optind)
    4021             :     {
    4022           0 :         if (errs)
    4023           0 :             optind--;           /* complain about the previous argument */
    4024             : 
    4025             :         /* spell the error message a bit differently depending on context */
    4026           0 :         if (IsUnderPostmaster)
    4027           0 :             ereport(FATAL,
    4028             :                     errcode(ERRCODE_SYNTAX_ERROR),
    4029             :                     errmsg("invalid command-line argument for server process: %s", argv[optind]),
    4030             :                     errhint("Try \"%s --help\" for more information.", progname));
    4031             :         else
    4032           0 :             ereport(FATAL,
    4033             :                     errcode(ERRCODE_SYNTAX_ERROR),
    4034             :                     errmsg("%s: invalid command-line argument: %s",
    4035             :                            progname, argv[optind]),
    4036             :                     errhint("Try \"%s --help\" for more information.", progname));
    4037             :     }
    4038             : 
    4039             :     /*
    4040             :      * Reset getopt(3) library so that it will work correctly in subprocesses
    4041             :      * or when this function is called a second time with another array.
    4042             :      */
    4043        7214 :     optind = 1;
    4044             : #ifdef HAVE_INT_OPTRESET
    4045             :     optreset = 1;               /* some systems need this too */
    4046             : #endif
    4047        7214 : }
    4048             : 
    4049             : 
    4050             : /*
    4051             :  * PostgresSingleUserMain
    4052             :  *     Entry point for single user mode. argc/argv are the command line
    4053             :  *     arguments to be used.
    4054             :  *
    4055             :  * Performs single user specific setup then calls PostgresMain() to actually
    4056             :  * process queries. Single user mode specific setup should go here, rather
    4057             :  * than PostgresMain() or InitPostgres() when reasonably possible.
    4058             :  */
    4059             : void
    4060         120 : PostgresSingleUserMain(int argc, char *argv[],
    4061             :                        const char *username)
    4062             : {
    4063         120 :     const char *dbname = NULL;
    4064             : 
    4065             :     Assert(!IsUnderPostmaster);
    4066             : 
    4067             :     /* Initialize startup process environment. */
    4068         120 :     InitStandaloneProcess(argv[0]);
    4069             : 
    4070             :     /*
    4071             :      * Set default values for command-line options.
    4072             :      */
    4073         120 :     InitializeGUCOptions();
    4074             : 
    4075             :     /*
    4076             :      * Parse command-line options.
    4077             :      */
    4078         120 :     process_postgres_switches(argc, argv, PGC_POSTMASTER, &dbname);
    4079             : 
    4080             :     /* Must have gotten a database name, or have a default (the username) */
    4081         120 :     if (dbname == NULL)
    4082             :     {
    4083           0 :         dbname = username;
    4084           0 :         if (dbname == NULL)
    4085           0 :             ereport(FATAL,
    4086             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    4087             :                      errmsg("%s: no database nor user name specified",
    4088             :                             progname)));
    4089             :     }
    4090             : 
    4091             :     /* Acquire configuration parameters */
    4092         120 :     if (!SelectConfigFiles(userDoption, progname))
    4093           0 :         proc_exit(1);
    4094             : 
    4095             :     /*
    4096             :      * Validate we have been given a reasonable-looking DataDir and change
    4097             :      * into it.
    4098             :      */
    4099         120 :     checkDataDir();
    4100         120 :     ChangeToDataDir();
    4101             : 
    4102             :     /*
    4103             :      * Create lockfile for data directory.
    4104             :      */
    4105         120 :     CreateDataDirLockFile(false);
    4106             : 
    4107             :     /* read control file (error checking and contains config ) */
    4108         118 :     LocalProcessControlFile(false);
    4109             : 
    4110             :     /*
    4111             :      * process any libraries that should be preloaded at postmaster start
    4112             :      */
    4113         118 :     process_shared_preload_libraries();
    4114             : 
    4115             :     /* Initialize MaxBackends */
    4116         118 :     InitializeMaxBackends();
    4117             : 
    4118             :     /*
    4119             :      * We don't need postmaster child slots in single-user mode, but
    4120             :      * initialize them anyway to avoid having special handling.
    4121             :      */
    4122         118 :     InitPostmasterChildSlots();
    4123             : 
    4124             :     /* Initialize size of fast-path lock cache. */
    4125         118 :     InitializeFastPathLocks();
    4126             : 
    4127             :     /*
    4128             :      * Give preloaded libraries a chance to request additional shared memory.
    4129             :      */
    4130         118 :     process_shmem_requests();
    4131             : 
    4132             :     /*
    4133             :      * Now that loadable modules have had their chance to request additional
    4134             :      * shared memory, determine the value of any runtime-computed GUCs that
    4135             :      * depend on the amount of shared memory required.
    4136             :      */
    4137         118 :     InitializeShmemGUCs();
    4138             : 
    4139             :     /*
    4140             :      * Now that modules have been loaded, we can process any custom resource
    4141             :      * managers specified in the wal_consistency_checking GUC.
    4142             :      */
    4143         118 :     InitializeWalConsistencyChecking();
    4144             : 
    4145             :     /*
    4146             :      * Create shared memory etc.  (Nothing's really "shared" in single-user
    4147             :      * mode, but we must have these data structures anyway.)
    4148             :      */
    4149         118 :     CreateSharedMemoryAndSemaphores();
    4150             : 
    4151             :     /*
    4152             :      * Estimate number of openable files.  This must happen after setting up
    4153             :      * semaphores, because on some platforms semaphores count as open files.
    4154             :      */
    4155         116 :     set_max_safe_fds();
    4156             : 
    4157             :     /*
    4158             :      * Remember stand-alone backend startup time,roughly at the same point
    4159             :      * during startup that postmaster does so.
    4160             :      */
    4161         116 :     PgStartTime = GetCurrentTimestamp();
    4162             : 
    4163             :     /*
    4164             :      * Create a per-backend PGPROC struct in shared memory. We must do this
    4165             :      * before we can use LWLocks.
    4166             :      */
    4167         116 :     InitProcess();
    4168             : 
    4169             :     /*
    4170             :      * Now that sufficient infrastructure has been initialized, PostgresMain()
    4171             :      * can do the rest.
    4172             :      */
    4173         116 :     PostgresMain(dbname, username);
    4174             : }
    4175             : 
    4176             : 
    4177             : /* ----------------------------------------------------------------
    4178             :  * PostgresMain
    4179             :  *     postgres main loop -- all backends, interactive or otherwise loop here
    4180             :  *
    4181             :  * dbname is the name of the database to connect to, username is the
    4182             :  * PostgreSQL user name to be used for the session.
    4183             :  *
    4184             :  * NB: Single user mode specific setup should go to PostgresSingleUserMain()
    4185             :  * if reasonably possible.
    4186             :  * ----------------------------------------------------------------
    4187             :  */
    4188             : void
    4189       25120 : PostgresMain(const char *dbname, const char *username)
    4190             : {
    4191             :     sigjmp_buf  local_sigjmp_buf;
    4192             : 
    4193             :     /* these must be volatile to ensure state is preserved across longjmp: */
    4194       25120 :     volatile bool send_ready_for_query = true;
    4195       25120 :     volatile bool idle_in_transaction_timeout_enabled = false;
    4196       25120 :     volatile bool idle_session_timeout_enabled = false;
    4197             : 
    4198             :     Assert(dbname != NULL);
    4199             :     Assert(username != NULL);
    4200             : 
    4201             :     Assert(GetProcessingMode() == InitProcessing);
    4202             : 
    4203             :     /*
    4204             :      * Set up signal handlers.  (InitPostmasterChild or InitStandaloneProcess
    4205             :      * has already set up BlockSig and made that the active signal mask.)
    4206             :      *
    4207             :      * Note that postmaster blocked all signals before forking child process,
    4208             :      * so there is no race condition whereby we might receive a signal before
    4209             :      * we have set up the handler.
    4210             :      *
    4211             :      * Also note: it's best not to use any signals that are SIG_IGNored in the
    4212             :      * postmaster.  If such a signal arrives before we are able to change the
    4213             :      * handler to non-SIG_IGN, it'll get dropped.  Instead, make a dummy
    4214             :      * handler in the postmaster to reserve the signal. (Of course, this isn't
    4215             :      * an issue for signals that are locally generated, such as SIGALRM and
    4216             :      * SIGPIPE.)
    4217             :      */
    4218       25120 :     if (am_walsender)
    4219        2206 :         WalSndSignals();
    4220             :     else
    4221             :     {
    4222       22914 :         pqsignal(SIGHUP, SignalHandlerForConfigReload);
    4223       22914 :         pqsignal(SIGINT, StatementCancelHandler);   /* cancel current query */
    4224       22914 :         pqsignal(SIGTERM, die); /* cancel current query and exit */
    4225             : 
    4226             :         /*
    4227             :          * In a postmaster child backend, replace SignalHandlerForCrashExit
    4228             :          * with quickdie, so we can tell the client we're dying.
    4229             :          *
    4230             :          * In a standalone backend, SIGQUIT can be generated from the keyboard
    4231             :          * easily, while SIGTERM cannot, so we make both signals do die()
    4232             :          * rather than quickdie().
    4233             :          */
    4234       22914 :         if (IsUnderPostmaster)
    4235       22798 :             pqsignal(SIGQUIT, quickdie);    /* hard crash time */
    4236             :         else
    4237         116 :             pqsignal(SIGQUIT, die); /* cancel current query and exit */
    4238       22914 :         InitializeTimeouts();   /* establishes SIGALRM handler */
    4239             : 
    4240             :         /*
    4241             :          * Ignore failure to write to frontend. Note: if frontend closes
    4242             :          * connection, we will notice it and exit cleanly when control next
    4243             :          * returns to outer loop.  This seems safer than forcing exit in the
    4244             :          * midst of output during who-knows-what operation...
    4245             :          */
    4246       22914 :         pqsignal(SIGPIPE, SIG_IGN);
    4247       22914 :         pqsignal(SIGUSR1, procsignal_sigusr1_handler);
    4248       22914 :         pqsignal(SIGUSR2, SIG_IGN);
    4249       22914 :         pqsignal(SIGFPE, FloatExceptionHandler);
    4250             : 
    4251             :         /*
    4252             :          * Reset some signals that are accepted by postmaster but not by
    4253             :          * backend
    4254             :          */
    4255       22914 :         pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
    4256             :                                      * platforms */
    4257             :     }
    4258             : 
    4259             :     /* Early initialization */
    4260       25120 :     BaseInit();
    4261             : 
    4262             :     /* We need to allow SIGINT, etc during the initial transaction */
    4263       25120 :     sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
    4264             : 
    4265             :     /*
    4266             :      * Generate a random cancel key, if this is a backend serving a
    4267             :      * connection. InitPostgres() will advertise it in shared memory.
    4268             :      */
    4269             :     Assert(MyCancelKeyLength == 0);
    4270       25120 :     if (whereToSendOutput == DestRemote)
    4271             :     {
    4272             :         int         len;
    4273             : 
    4274       25004 :         len = (MyProcPort == NULL || MyProcPort->proto >= PG_PROTOCOL(3, 2))
    4275       50008 :             ? MAX_CANCEL_KEY_LENGTH : 4;
    4276       25004 :         if (!pg_strong_random(&MyCancelKey, len))
    4277             :         {
    4278           0 :             ereport(ERROR,
    4279             :                     (errcode(ERRCODE_INTERNAL_ERROR),
    4280             :                      errmsg("could not generate random cancel key")));
    4281             :         }
    4282       25004 :         MyCancelKeyLength = len;
    4283             :     }
    4284             : 
    4285             :     /*
    4286             :      * General initialization.
    4287             :      *
    4288             :      * NOTE: if you are tempted to add code in this vicinity, consider putting
    4289             :      * it inside InitPostgres() instead.  In particular, anything that
    4290             :      * involves database access should be there, not here.
    4291             :      *
    4292             :      * Honor session_preload_libraries if not dealing with a WAL sender.
    4293             :      */
    4294       25120 :     InitPostgres(dbname, InvalidOid,    /* database to connect to */
    4295             :                  username, InvalidOid,  /* role to connect as */
    4296       25120 :                  (!am_walsender) ? INIT_PG_LOAD_SESSION_LIBS : 0,
    4297             :                  NULL);         /* no out_dbname */
    4298             : 
    4299             :     /*
    4300             :      * If the PostmasterContext is still around, recycle the space; we don't
    4301             :      * need it anymore after InitPostgres completes.
    4302             :      */
    4303       24944 :     if (PostmasterContext)
    4304             :     {
    4305       24832 :         MemoryContextDelete(PostmasterContext);
    4306       24832 :         PostmasterContext = NULL;
    4307             :     }
    4308             : 
    4309       24944 :     SetProcessingMode(NormalProcessing);
    4310             : 
    4311             :     /*
    4312             :      * Now all GUC states are fully set up.  Report them to client if
    4313             :      * appropriate.
    4314             :      */
    4315       24944 :     BeginReportingGUCOptions();
    4316             : 
    4317             :     /*
    4318             :      * Also set up handler to log session end; we have to wait till now to be
    4319             :      * sure Log_disconnections has its final value.
    4320             :      */
    4321       24944 :     if (IsUnderPostmaster && Log_disconnections)
    4322          80 :         on_proc_exit(log_disconnections, 0);
    4323             : 
    4324       24944 :     pgstat_report_connect(MyDatabaseId);
    4325             : 
    4326             :     /* Perform initialization specific to a WAL sender process. */
    4327       24944 :     if (am_walsender)
    4328        2206 :         InitWalSender();
    4329             : 
    4330             :     /*
    4331             :      * Send this backend's cancellation info to the frontend.
    4332             :      */
    4333       24944 :     if (whereToSendOutput == DestRemote)
    4334             :     {
    4335             :         StringInfoData buf;
    4336             : 
    4337             :         Assert(MyCancelKeyLength > 0);
    4338       24832 :         pq_beginmessage(&buf, PqMsg_BackendKeyData);
    4339       24832 :         pq_sendint32(&buf, (int32) MyProcPid);
    4340             : 
    4341       24832 :         pq_sendbytes(&buf, MyCancelKey, MyCancelKeyLength);
    4342       24832 :         pq_endmessage(&buf);
    4343             :         /* Need not flush since ReadyForQuery will do it. */
    4344             :     }
    4345             : 
    4346             :     /* Welcome banner for standalone case */
    4347       24944 :     if (whereToSendOutput == DestDebug)
    4348         112 :         printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION);
    4349             : 
    4350             :     /*
    4351             :      * Create the memory context we will use in the main loop.
    4352             :      *
    4353             :      * MessageContext is reset once per iteration of the main loop, ie, upon
    4354             :      * completion of processing of each command message from the client.
    4355             :      */
    4356       24944 :     MessageContext = AllocSetContextCreate(TopMemoryContext,
    4357             :                                            "MessageContext",
    4358             :                                            ALLOCSET_DEFAULT_SIZES);
    4359             : 
    4360             :     /*
    4361             :      * Create memory context and buffer used for RowDescription messages. As
    4362             :      * SendRowDescriptionMessage(), via exec_describe_statement_message(), is
    4363             :      * frequently executed for ever single statement, we don't want to
    4364             :      * allocate a separate buffer every time.
    4365             :      */
    4366       24944 :     row_description_context = AllocSetContextCreate(TopMemoryContext,
    4367             :                                                     "RowDescriptionContext",
    4368             :                                                     ALLOCSET_DEFAULT_SIZES);
    4369       24944 :     MemoryContextSwitchTo(row_description_context);
    4370       24944 :     initStringInfo(&row_description_buf);
    4371       24944 :     MemoryContextSwitchTo(TopMemoryContext);
    4372             : 
    4373             :     /* Fire any defined login event triggers, if appropriate */
    4374       24944 :     EventTriggerOnLogin();
    4375             : 
    4376             :     /*
    4377             :      * POSTGRES main processing loop begins here
    4378             :      *
    4379             :      * If an exception is encountered, processing resumes here so we abort the
    4380             :      * current transaction and start a new one.
    4381             :      *
    4382             :      * You might wonder why this isn't coded as an infinite loop around a
    4383             :      * PG_TRY construct.  The reason is that this is the bottom of the
    4384             :      * exception stack, and so with PG_TRY there would be no exception handler
    4385             :      * in force at all during the CATCH part.  By leaving the outermost setjmp
    4386             :      * always active, we have at least some chance of recovering from an error
    4387             :      * during error recovery.  (If we get into an infinite loop thereby, it
    4388             :      * will soon be stopped by overflow of elog.c's internal state stack.)
    4389             :      *
    4390             :      * Note that we use sigsetjmp(..., 1), so that this function's signal mask
    4391             :      * (to wit, UnBlockSig) will be restored when longjmp'ing to here.  This
    4392             :      * is essential in case we longjmp'd out of a signal handler on a platform
    4393             :      * where that leaves the signal blocked.  It's not redundant with the
    4394             :      * unblock in AbortTransaction() because the latter is only called if we
    4395             :      * were inside a transaction.
    4396             :      */
    4397             : 
    4398       24944 :     if (sigsetjmp(local_sigjmp_buf, 1) != 0)
    4399             :     {
    4400             :         /*
    4401             :          * NOTE: if you are tempted to add more code in this if-block,
    4402             :          * consider the high probability that it should be in
    4403             :          * AbortTransaction() instead.  The only stuff done directly here
    4404             :          * should be stuff that is guaranteed to apply *only* for outer-level
    4405             :          * error recovery, such as adjusting the FE/BE protocol status.
    4406             :          */
    4407             : 
    4408             :         /* Since not using PG_TRY, must reset error stack by hand */
    4409       43008 :         error_context_stack = NULL;
    4410             : 
    4411             :         /* Prevent interrupts while cleaning up */
    4412       43008 :         HOLD_INTERRUPTS();
    4413             : 
    4414             :         /*
    4415             :          * Forget any pending QueryCancel request, since we're returning to
    4416             :          * the idle loop anyway, and cancel any active timeout requests.  (In
    4417             :          * future we might want to allow some timeout requests to survive, but
    4418             :          * at minimum it'd be necessary to do reschedule_timeouts(), in case
    4419             :          * we got here because of a query cancel interrupting the SIGALRM
    4420             :          * interrupt handler.)  Note in particular that we must clear the
    4421             :          * statement and lock timeout indicators, to prevent any future plain
    4422             :          * query cancels from being misreported as timeouts in case we're
    4423             :          * forgetting a timeout cancel.
    4424             :          */
    4425       43008 :         disable_all_timeouts(false);    /* do first to avoid race condition */
    4426       43008 :         QueryCancelPending = false;
    4427       43008 :         idle_in_transaction_timeout_enabled = false;
    4428       43008 :         idle_session_timeout_enabled = false;
    4429             : 
    4430             :         /* Not reading from the client anymore. */
    4431       43008 :         DoingCommandRead = false;
    4432             : 
    4433             :         /* Make sure libpq is in a good state */
    4434       43008 :         pq_comm_reset();
    4435             : 
    4436             :         /* Report the error to the client and/or server log */
    4437       43008 :         EmitErrorReport();
    4438             : 
    4439             :         /*
    4440             :          * If Valgrind noticed something during the erroneous query, print the
    4441             :          * query string, assuming we have one.
    4442             :          */
    4443             :         valgrind_report_error_query(debug_query_string);
    4444             : 
    4445             :         /*
    4446             :          * Make sure debug_query_string gets reset before we possibly clobber
    4447             :          * the storage it points at.
    4448             :          */
    4449       43008 :         debug_query_string = NULL;
    4450             : 
    4451             :         /*
    4452             :          * Abort the current transaction in order to recover.
    4453             :          */
    4454       43008 :         AbortCurrentTransaction();
    4455             : 
    4456       43008 :         if (am_walsender)
    4457         104 :             WalSndErrorCleanup();
    4458             : 
    4459       43008 :         PortalErrorCleanup();
    4460             : 
    4461             :         /*
    4462             :          * We can't release replication slots inside AbortTransaction() as we
    4463             :          * need to be able to start and abort transactions while having a slot
    4464             :          * acquired. But we never need to hold them across top level errors,
    4465             :          * so releasing here is fine. There also is a before_shmem_exit()
    4466             :          * callback ensuring correct cleanup on FATAL errors.
    4467             :          */
    4468       43008 :         if (MyReplicationSlot != NULL)
    4469          28 :             ReplicationSlotRelease();
    4470             : 
    4471             :         /* We also want to cleanup temporary slots on error. */
    4472       43008 :         ReplicationSlotCleanup(false);
    4473             : 
    4474       43008 :         jit_reset_after_error();
    4475             : 
    4476             :         /*
    4477             :          * Now return to normal top-level context and clear ErrorContext for
    4478             :          * next time.
    4479             :          */
    4480       43008 :         MemoryContextSwitchTo(MessageContext);
    4481       43008 :         FlushErrorState();
    4482             : 
    4483             :         /*
    4484             :          * If we were handling an extended-query-protocol message, initiate
    4485             :          * skip till next Sync.  This also causes us not to issue
    4486             :          * ReadyForQuery (until we get Sync).
    4487             :          */
    4488       43008 :         if (doing_extended_query_message)
    4489         216 :             ignore_till_sync = true;
    4490             : 
    4491             :         /* We don't have a transaction command open anymore */
    4492       43008 :         xact_started = false;
    4493             : 
    4494             :         /*
    4495             :          * If an error occurred while we were reading a message from the
    4496             :          * client, we have potentially lost track of where the previous
    4497             :          * message ends and the next one begins.  Even though we have
    4498             :          * otherwise recovered from the error, we cannot safely read any more
    4499             :          * messages from the client, so there isn't much we can do with the
    4500             :          * connection anymore.
    4501             :          */
    4502       43008 :         if (pq_is_reading_msg())
    4503           6 :             ereport(FATAL,
    4504             :                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
    4505             :                      errmsg("terminating connection because protocol synchronization was lost")));
    4506             : 
    4507             :         /* Now we can allow interrupts again */
    4508       43002 :         RESUME_INTERRUPTS();
    4509             :     }
    4510             : 
    4511             :     /* We can now handle ereport(ERROR) */
    4512       67946 :     PG_exception_stack = &local_sigjmp_buf;
    4513             : 
    4514       67946 :     if (!ignore_till_sync)
    4515       67736 :         send_ready_for_query = true;    /* initially, or after error */
    4516             : 
    4517             :     /*
    4518             :      * Non-error queries loop here.
    4519             :      */
    4520             : 
    4521             :     for (;;)
    4522      745864 :     {
    4523             :         int         firstchar;
    4524             :         StringInfoData input_message;
    4525             : 
    4526             :         /*
    4527             :          * At top of loop, reset extended-query-message flag, so that any
    4528             :          * errors encountered in "idle" state don't provoke skip.
    4529             :          */
    4530      813810 :         doing_extended_query_message = false;
    4531             : 
    4532             :         /*
    4533             :          * For valgrind reporting purposes, the "current query" begins here.
    4534             :          */
    4535             : #ifdef USE_VALGRIND
    4536             :         old_valgrind_error_count = VALGRIND_COUNT_ERRORS;
    4537             : #endif
    4538             : 
    4539             :         /*
    4540             :          * Release storage left over from prior query cycle, and create a new
    4541             :          * query input buffer in the cleared MessageContext.
    4542             :          */
    4543      813810 :         MemoryContextSwitchTo(MessageContext);
    4544      813810 :         MemoryContextReset(MessageContext);
    4545             : 
    4546      813810 :         initStringInfo(&input_message);
    4547             : 
    4548             :         /*
    4549             :          * Also consider releasing our catalog snapshot if any, so that it's
    4550             :          * not preventing advance of global xmin while we wait for the client.
    4551             :          */
    4552      813810 :         InvalidateCatalogSnapshotConditionally();
    4553             : 
    4554             :         /*
    4555             :          * (1) If we've reached idle state, tell the frontend we're ready for
    4556             :          * a new query.
    4557             :          *
    4558             :          * Note: this includes fflush()'ing the last of the prior output.
    4559             :          *
    4560             :          * This is also a good time to flush out collected statistics to the
    4561             :          * cumulative stats system, and to update the PS stats display.  We
    4562             :          * avoid doing those every time through the message loop because it'd
    4563             :          * slow down processing of batched messages, and because we don't want
    4564             :          * to report uncommitted updates (that confuses autovacuum).  The
    4565             :          * notification processor wants a call too, if we are not in a
    4566             :          * transaction block.
    4567             :          *
    4568             :          * Also, if an idle timeout is enabled, start the timer for that.
    4569             :          */
    4570      813810 :         if (send_ready_for_query)
    4571             :         {
    4572      735398 :             if (IsAbortedTransactionBlockState())
    4573             :             {
    4574        1794 :                 set_ps_display("idle in transaction (aborted)");
    4575        1794 :                 pgstat_report_activity(STATE_IDLEINTRANSACTION_ABORTED, NULL);
    4576             : 
    4577             :                 /* Start the idle-in-transaction timer */
    4578        1794 :                 if (IdleInTransactionSessionTimeout > 0
    4579           0 :                     && (IdleInTransactionSessionTimeout < TransactionTimeout || TransactionTimeout == 0))
    4580             :                 {
    4581           0 :                     idle_in_transaction_timeout_enabled = true;
    4582           0 :                     enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
    4583             :                                          IdleInTransactionSessionTimeout);
    4584             :                 }
    4585             :             }
    4586      733604 :             else if (IsTransactionOrTransactionBlock())
    4587             :             {
    4588      171326 :                 set_ps_display("idle in transaction");
    4589      171326 :                 pgstat_report_activity(STATE_IDLEINTRANSACTION, NULL);
    4590             : 
    4591             :                 /* Start the idle-in-transaction timer */
    4592      171326 :                 if (IdleInTransactionSessionTimeout > 0
    4593           2 :                     && (IdleInTransactionSessionTimeout < TransactionTimeout || TransactionTimeout == 0))
    4594             :                 {
    4595           2 :                     idle_in_transaction_timeout_enabled = true;
    4596           2 :                     enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
    4597             :                                          IdleInTransactionSessionTimeout);
    4598             :                 }
    4599             :             }
    4600             :             else
    4601             :             {
    4602             :                 long        stats_timeout;
    4603             : 
    4604             :                 /*
    4605             :                  * Process incoming notifies (including self-notifies), if
    4606             :                  * any, and send relevant messages to the client.  Doing it
    4607             :                  * here helps ensure stable behavior in tests: if any notifies
    4608             :                  * were received during the just-finished transaction, they'll
    4609             :                  * be seen by the client before ReadyForQuery is.
    4610             :                  */
    4611      562278 :                 if (notifyInterruptPending)
    4612          58 :                     ProcessNotifyInterrupt(false);
    4613             : 
    4614             :                 /*
    4615             :                  * Check if we need to report stats. If pgstat_report_stat()
    4616             :                  * decides it's too soon to flush out pending stats / lock
    4617             :                  * contention prevented reporting, it'll tell us when we
    4618             :                  * should try to report stats again (so that stats updates
    4619             :                  * aren't unduly delayed if the connection goes idle for a
    4620             :                  * long time). We only enable the timeout if we don't already
    4621             :                  * have a timeout in progress, because we don't disable the
    4622             :                  * timeout below. enable_timeout_after() needs to determine
    4623             :                  * the current timestamp, which can have a negative
    4624             :                  * performance impact. That's OK because pgstat_report_stat()
    4625             :                  * won't have us wake up sooner than a prior call.
    4626             :                  */
    4627      562278 :                 stats_timeout = pgstat_report_stat(false);
    4628      562278 :                 if (stats_timeout > 0)
    4629             :                 {
    4630      529606 :                     if (!get_timeout_active(IDLE_STATS_UPDATE_TIMEOUT))
    4631       67508 :                         enable_timeout_after(IDLE_STATS_UPDATE_TIMEOUT,
    4632             :                                              stats_timeout);
    4633             :                 }
    4634             :                 else
    4635             :                 {
    4636             :                     /* all stats flushed, no need for the timeout */
    4637       32672 :                     if (get_timeout_active(IDLE_STATS_UPDATE_TIMEOUT))
    4638        1932 :                         disable_timeout(IDLE_STATS_UPDATE_TIMEOUT, false);
    4639             :                 }
    4640             : 
    4641      562278 :                 set_ps_display("idle");
    4642      562278 :                 pgstat_report_activity(STATE_IDLE, NULL);
    4643             : 
    4644             :                 /* Start the idle-session timer */
    4645      562278 :                 if (IdleSessionTimeout > 0)
    4646             :                 {
    4647           0 :                     idle_session_timeout_enabled = true;
    4648           0 :                     enable_timeout_after(IDLE_SESSION_TIMEOUT,
    4649             :                                          IdleSessionTimeout);
    4650             :                 }
    4651             :             }
    4652             : 
    4653             :             /* Report any recently-changed GUC options */
    4654      735398 :             ReportChangedGUCOptions();
    4655             : 
    4656             :             /*
    4657             :              * The first time this backend is ready for query, log the
    4658             :              * durations of the different components of connection
    4659             :              * establishment and setup.
    4660             :              */
    4661      735398 :             if (conn_timing.ready_for_use == TIMESTAMP_MINUS_INFINITY &&
    4662      735238 :                 (log_connections & LOG_CONNECTION_SETUP_DURATIONS) &&
    4663         126 :                 IsExternalConnectionBackend(MyBackendType))
    4664             :             {
    4665             :                 uint64      total_duration,
    4666             :                             fork_duration,
    4667             :                             auth_duration;
    4668             : 
    4669         126 :                 conn_timing.ready_for_use = GetCurrentTimestamp();
    4670             : 
    4671             :                 total_duration =
    4672         126 :                     TimestampDifferenceMicroseconds(conn_timing.socket_create,
    4673             :                                                     conn_timing.ready_for_use);
    4674             :                 fork_duration =
    4675         126 :                     TimestampDifferenceMicroseconds(conn_timing.fork_start,
    4676             :                                                     conn_timing.fork_end);
    4677             :                 auth_duration =
    4678         126 :                     TimestampDifferenceMicroseconds(conn_timing.auth_start,
    4679             :                                                     conn_timing.auth_end);
    4680             : 
    4681         126 :                 ereport(LOG,
    4682             :                         errmsg("connection ready: setup total=%.3f ms, fork=%.3f ms, authentication=%.3f ms",
    4683             :                                (double) total_duration / NS_PER_US,
    4684             :                                (double) fork_duration / NS_PER_US,
    4685             :                                (double) auth_duration / NS_PER_US));
    4686             :             }
    4687             : 
    4688      735398 :             ReadyForQuery(whereToSendOutput);
    4689      735398 :             send_ready_for_query = false;
    4690             :         }
    4691             : 
    4692             :         /*
    4693             :          * (2) Allow asynchronous signals to be executed immediately if they
    4694             :          * come in while we are waiting for client input. (This must be
    4695             :          * conditional since we don't want, say, reads on behalf of COPY FROM
    4696             :          * STDIN doing the same thing.)
    4697             :          */
    4698      813810 :         DoingCommandRead = true;
    4699             : 
    4700             :         /*
    4701             :          * (3) read a command (loop blocks here)
    4702             :          */
    4703      813810 :         firstchar = ReadCommand(&input_message);
    4704             : 
    4705             :         /*
    4706             :          * (4) turn off the idle-in-transaction and idle-session timeouts if
    4707             :          * active.  We do this before step (5) so that any last-moment timeout
    4708             :          * is certain to be detected in step (5).
    4709             :          *
    4710             :          * At most one of these timeouts will be active, so there's no need to
    4711             :          * worry about combining the timeout.c calls into one.
    4712             :          */
    4713      813724 :         if (idle_in_transaction_timeout_enabled)
    4714             :         {
    4715           0 :             disable_timeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, false);
    4716           0 :             idle_in_transaction_timeout_enabled = false;
    4717             :         }
    4718      813724 :         if (idle_session_timeout_enabled)
    4719             :         {
    4720           0 :             disable_timeout(IDLE_SESSION_TIMEOUT, false);
    4721           0 :             idle_session_timeout_enabled = false;
    4722             :         }
    4723             : 
    4724             :         /*
    4725             :          * (5) disable async signal conditions again.
    4726             :          *
    4727             :          * Query cancel is supposed to be a no-op when there is no query in
    4728             :          * progress, so if a query cancel arrived while we were idle, just
    4729             :          * reset QueryCancelPending. ProcessInterrupts() has that effect when
    4730             :          * it's called when DoingCommandRead is set, so check for interrupts
    4731             :          * before resetting DoingCommandRead.
    4732             :          */
    4733      813724 :         CHECK_FOR_INTERRUPTS();
    4734      813722 :         DoingCommandRead = false;
    4735             : 
    4736             :         /*
    4737             :          * (6) check for any other interesting events that happened while we
    4738             :          * slept.
    4739             :          */
    4740      813722 :         if (ConfigReloadPending)
    4741             :         {
    4742          26 :             ConfigReloadPending = false;
    4743          26 :             ProcessConfigFile(PGC_SIGHUP);
    4744             :         }
    4745             : 
    4746             :         /*
    4747             :          * (7) process the command.  But ignore it if we're skipping till
    4748             :          * Sync.
    4749             :          */
    4750      813722 :         if (ignore_till_sync && firstchar != EOF)
    4751        1772 :             continue;
    4752             : 
    4753      811950 :         switch (firstchar)
    4754             :         {
    4755      685940 :             case PqMsg_Query:
    4756             :                 {
    4757             :                     const char *query_string;
    4758             : 
    4759             :                     /* Set statement_timestamp() */
    4760      685940 :                     SetCurrentStatementStartTimestamp();
    4761             : 
    4762      685940 :                     query_string = pq_getmsgstring(&input_message);
    4763      685940 :                     pq_getmsgend(&input_message);
    4764             : 
    4765      685940 :                     if (am_walsender)
    4766             :                     {
    4767       10134 :                         if (!exec_replication_command(query_string))
    4768        4490 :                             exec_simple_query(query_string);
    4769             :                     }
    4770             :                     else
    4771      675806 :                         exec_simple_query(query_string);
    4772             : 
    4773             :                     valgrind_report_error_query(query_string);
    4774             : 
    4775      642566 :                     send_ready_for_query = true;
    4776             :                 }
    4777      642566 :                 break;
    4778             : 
    4779       11124 :             case PqMsg_Parse:
    4780             :                 {
    4781             :                     const char *stmt_name;
    4782             :                     const char *query_string;
    4783             :                     int         numParams;
    4784       11124 :                     Oid        *paramTypes = NULL;
    4785             : 
    4786       11124 :                     forbidden_in_wal_sender(firstchar);
    4787             : 
    4788             :                     /* Set statement_timestamp() */
    4789       11124 :                     SetCurrentStatementStartTimestamp();
    4790             : 
    4791       11124 :                     stmt_name = pq_getmsgstring(&input_message);
    4792       11124 :                     query_string = pq_getmsgstring(&input_message);
    4793       11124 :                     numParams = pq_getmsgint(&input_message, 2);
    4794       11124 :                     if (numParams > 0)
    4795             :                     {
    4796          92 :                         paramTypes = palloc_array(Oid, numParams);
    4797         236 :                         for (int i = 0; i < numParams; i++)
    4798         144 :                             paramTypes[i] = pq_getmsgint(&input_message, 4);
    4799             :                     }
    4800       11124 :                     pq_getmsgend(&input_message);
    4801             : 
    4802       11124 :                     exec_parse_message(query_string, stmt_name,
    4803             :                                        paramTypes, numParams);
    4804             : 
    4805             :                     valgrind_report_error_query(query_string);
    4806             :                 }
    4807       11078 :                 break;
    4808             : 
    4809       21726 :             case PqMsg_Bind:
    4810       21726 :                 forbidden_in_wal_sender(firstchar);
    4811             : 
    4812             :                 /* Set statement_timestamp() */
    4813       21726 :                 SetCurrentStatementStartTimestamp();
    4814             : 
    4815             :                 /*
    4816             :                  * this message is complex enough that it seems best to put
    4817             :                  * the field extraction out-of-line
    4818             :                  */
    4819       21726 :                 exec_bind_message(&input_message);
    4820             : 
    4821             :                 /* exec_bind_message does valgrind_report_error_query */
    4822       21660 :                 break;
    4823             : 
    4824       21660 :             case PqMsg_Execute:
    4825             :                 {
    4826             :                     const char *portal_name;
    4827             :                     int         max_rows;
    4828             : 
    4829       21660 :                     forbidden_in_wal_sender(firstchar);
    4830             : 
    4831             :                     /* Set statement_timestamp() */
    4832       21660 :                     SetCurrentStatementStartTimestamp();
    4833             : 
    4834       21660 :                     portal_name = pq_getmsgstring(&input_message);
    4835       21660 :                     max_rows = pq_getmsgint(&input_message, 4);
    4836       21660 :                     pq_getmsgend(&input_message);
    4837             : 
    4838       21660 :                     exec_execute_message(portal_name, max_rows);
    4839             : 
    4840             :                     /* exec_execute_message does valgrind_report_error_query */
    4841             :                 }
    4842       21560 :                 break;
    4843             : 
    4844        2208 :             case PqMsg_FunctionCall:
    4845        2208 :                 forbidden_in_wal_sender(firstchar);
    4846             : 
    4847             :                 /* Set statement_timestamp() */
    4848        2208 :                 SetCurrentStatementStartTimestamp();
    4849             : 
    4850             :                 /* Report query to various monitoring facilities. */
    4851        2208 :                 pgstat_report_activity(STATE_FASTPATH, NULL);
    4852        2208 :                 set_ps_display("<FASTPATH>");
    4853             : 
    4854             :                 /* start an xact for this function invocation */
    4855        2208 :                 start_xact_command();
    4856             : 
    4857             :                 /*
    4858             :                  * Note: we may at this point be inside an aborted
    4859             :                  * transaction.  We can't throw error for that until we've
    4860             :                  * finished reading the function-call message, so
    4861             :                  * HandleFunctionRequest() must check for it after doing so.
    4862             :                  * Be careful not to do anything that assumes we're inside a
    4863             :                  * valid transaction here.
    4864             :                  */
    4865             : 
    4866             :                 /* switch back to message context */
    4867        2208 :                 MemoryContextSwitchTo(MessageContext);
    4868             : 
    4869        2208 :                 HandleFunctionRequest(&input_message);
    4870             : 
    4871             :                 /* commit the function-invocation transaction */
    4872        2208 :                 finish_xact_command();
    4873             : 
    4874             :                 valgrind_report_error_query("fastpath function call");
    4875             : 
    4876        2208 :                 send_ready_for_query = true;
    4877        2208 :                 break;
    4878             : 
    4879          32 :             case PqMsg_Close:
    4880             :                 {
    4881             :                     int         close_type;
    4882             :                     const char *close_target;
    4883             : 
    4884          32 :                     forbidden_in_wal_sender(firstchar);
    4885             : 
    4886          32 :                     close_type = pq_getmsgbyte(&input_message);
    4887          32 :                     close_target = pq_getmsgstring(&input_message);
    4888          32 :                     pq_getmsgend(&input_message);
    4889             : 
    4890             :                     switch (close_type)
    4891             :                     {
    4892          28 :                         case 'S':
    4893          28 :                             if (close_target[0] != '\0')
    4894          22 :                                 DropPreparedStatement(close_target, false);
    4895             :                             else
    4896             :                             {
    4897             :                                 /* special-case the unnamed statement */
    4898           6 :                                 drop_unnamed_stmt();
    4899             :                             }
    4900          28 :                             break;
    4901           4 :                         case 'P':
    4902             :                             {
    4903             :                                 Portal      portal;
    4904             : 
    4905           4 :                                 portal = GetPortalByName(close_target);
    4906           4 :                                 if (PortalIsValid(portal))
    4907           2 :                                     PortalDrop(portal, false);
    4908             :                             }
    4909           4 :                             break;
    4910           0 :                         default:
    4911           0 :                             ereport(ERROR,
    4912             :                                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
    4913             :                                      errmsg("invalid CLOSE message subtype %d",
    4914             :                                             close_type)));
    4915             :                             break;
    4916             :                     }
    4917             : 
    4918          32 :                     if (whereToSendOutput == DestRemote)
    4919          32 :                         pq_putemptymessage(PqMsg_CloseComplete);
    4920             : 
    4921             :                     valgrind_report_error_query("CLOSE message");
    4922             :                 }
    4923          32 :                 break;
    4924             : 
    4925       21806 :             case PqMsg_Describe:
    4926             :                 {
    4927             :                     int         describe_type;
    4928             :                     const char *describe_target;
    4929             : 
    4930       21806 :                     forbidden_in_wal_sender(firstchar);
    4931             : 
    4932             :                     /* Set statement_timestamp() (needed for xact) */
    4933       21806 :                     SetCurrentStatementStartTimestamp();
    4934             : 
    4935       21806 :                     describe_type = pq_getmsgbyte(&input_message);
    4936       21806 :                     describe_target = pq_getmsgstring(&input_message);
    4937       21806 :                     pq_getmsgend(&input_message);
    4938             : 
    4939             :                     switch (describe_type)
    4940             :                     {
    4941         142 :                         case 'S':
    4942         142 :                             exec_describe_statement_message(describe_target);
    4943         140 :                             break;
    4944       21664 :                         case 'P':
    4945       21664 :                             exec_describe_portal_message(describe_target);
    4946       21662 :                             break;
    4947           0 :                         default:
    4948           0 :                             ereport(ERROR,
    4949             :                                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
    4950             :                                      errmsg("invalid DESCRIBE message subtype %d",
    4951             :                                             describe_type)));
    4952             :                             break;
    4953             :                     }
    4954             : 
    4955             :                     valgrind_report_error_query("DESCRIBE message");
    4956             :                 }
    4957       21802 :                 break;
    4958             : 
    4959          62 :             case PqMsg_Flush:
    4960          62 :                 pq_getmsgend(&input_message);
    4961          62 :                 if (whereToSendOutput == DestRemote)
    4962          62 :                     pq_flush();
    4963          62 :                 break;
    4964             : 
    4965       22888 :             case PqMsg_Sync:
    4966       22888 :                 pq_getmsgend(&input_message);
    4967             : 
    4968             :                 /*
    4969             :                  * If pipelining was used, we may be in an implicit
    4970             :                  * transaction block. Close it before calling
    4971             :                  * finish_xact_command.
    4972             :                  */
    4973       22888 :                 EndImplicitTransactionBlock();
    4974       22888 :                 finish_xact_command();
    4975             :                 valgrind_report_error_query("SYNC message");
    4976       22888 :                 send_ready_for_query = true;
    4977       22888 :                 break;
    4978             : 
    4979             :                 /*
    4980             :                  * PqMsg_Terminate means that the frontend is closing down the
    4981             :                  * socket. EOF means unexpected loss of frontend connection.
    4982             :                  * Either way, perform normal shutdown.
    4983             :                  */
    4984         202 :             case EOF:
    4985             : 
    4986             :                 /* for the cumulative statistics system */
    4987         202 :                 pgStatSessionEndCause = DISCONNECT_CLIENT_EOF;
    4988             : 
    4989             :                 /* FALLTHROUGH */
    4990             : 
    4991       24268 :             case PqMsg_Terminate:
    4992             : 
    4993             :                 /*
    4994             :                  * Reset whereToSendOutput to prevent ereport from attempting
    4995             :                  * to send any more messages to client.
    4996             :                  */
    4997       24268 :                 if (whereToSendOutput == DestRemote)
    4998       24074 :                     whereToSendOutput = DestNone;
    4999             : 
    5000             :                 /*
    5001             :                  * NOTE: if you are tempted to add more code here, DON'T!
    5002             :                  * Whatever you had in mind to do should be set up as an
    5003             :                  * on_proc_exit or on_shmem_exit callback, instead. Otherwise
    5004             :                  * it will fail to be called during other backend-shutdown
    5005             :                  * scenarios.
    5006             :                  */
    5007       24268 :                 proc_exit(0);
    5008             : 
    5009         236 :             case PqMsg_CopyData:
    5010             :             case PqMsg_CopyDone:
    5011             :             case PqMsg_CopyFail:
    5012             : 
    5013             :                 /*
    5014             :                  * Accept but ignore these messages, per protocol spec; we
    5015             :                  * probably got here because a COPY failed, and the frontend
    5016             :                  * is still sending data.
    5017             :                  */
    5018         236 :                 break;
    5019             : 
    5020           0 :             default:
    5021           0 :                 ereport(FATAL,
    5022             :                         (errcode(ERRCODE_PROTOCOL_VIOLATION),
    5023             :                          errmsg("invalid frontend message type %d",
    5024             :                                 firstchar)));
    5025             :         }
    5026             :     }                           /* end of input-reading loop */
    5027             : }
    5028             : 
    5029             : /*
    5030             :  * Throw an error if we're a WAL sender process.
    5031             :  *
    5032             :  * This is used to forbid anything else than simple query protocol messages
    5033             :  * in a WAL sender process.  'firstchar' specifies what kind of a forbidden
    5034             :  * message was received, and is used to construct the error message.
    5035             :  */
    5036             : static void
    5037       78556 : forbidden_in_wal_sender(char firstchar)
    5038             : {
    5039       78556 :     if (am_walsender)
    5040             :     {
    5041           0 :         if (firstchar == PqMsg_FunctionCall)
    5042           0 :             ereport(ERROR,
    5043             :                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
    5044             :                      errmsg("fastpath function calls not supported in a replication connection")));
    5045             :         else
    5046           0 :             ereport(ERROR,
    5047             :                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
    5048             :                      errmsg("extended query protocol not supported in a replication connection")));
    5049             :     }
    5050       78556 : }
    5051             : 
    5052             : 
    5053             : static struct rusage Save_r;
    5054             : static struct timeval Save_t;
    5055             : 
    5056             : void
    5057           0 : ResetUsage(void)
    5058             : {
    5059           0 :     getrusage(RUSAGE_SELF, &Save_r);
    5060           0 :     gettimeofday(&Save_t, NULL);
    5061           0 : }
    5062             : 
    5063             : void
    5064           0 : ShowUsage(const char *title)
    5065             : {
    5066             :     StringInfoData str;
    5067             :     struct timeval user,
    5068             :                 sys;
    5069             :     struct timeval elapse_t;
    5070             :     struct rusage r;
    5071             : 
    5072           0 :     getrusage(RUSAGE_SELF, &r);
    5073           0 :     gettimeofday(&elapse_t, NULL);
    5074           0 :     memcpy(&user, &r.ru_utime, sizeof(user));
    5075           0 :     memcpy(&sys, &r.ru_stime, sizeof(sys));
    5076           0 :     if (elapse_t.tv_usec < Save_t.tv_usec)
    5077             :     {
    5078           0 :         elapse_t.tv_sec--;
    5079           0 :         elapse_t.tv_usec += 1000000;
    5080             :     }
    5081           0 :     if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
    5082             :     {
    5083           0 :         r.ru_utime.tv_sec--;
    5084           0 :         r.ru_utime.tv_usec += 1000000;
    5085             :     }
    5086           0 :     if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
    5087             :     {
    5088           0 :         r.ru_stime.tv_sec--;
    5089           0 :         r.ru_stime.tv_usec += 1000000;
    5090             :     }
    5091             : 
    5092             :     /*
    5093             :      * The only stats we don't show here are ixrss, idrss, isrss.  It takes
    5094             :      * some work to interpret them, and most platforms don't fill them in.
    5095             :      */
    5096           0 :     initStringInfo(&str);
    5097             : 
    5098           0 :     appendStringInfoString(&str, "! system usage stats:\n");
    5099           0 :     appendStringInfo(&str,
    5100             :                      "!\t%ld.%06ld s user, %ld.%06ld s system, %ld.%06ld s elapsed\n",
    5101           0 :                      (long) (r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec),
    5102           0 :                      (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
    5103           0 :                      (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
    5104           0 :                      (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec),
    5105           0 :                      (long) (elapse_t.tv_sec - Save_t.tv_sec),
    5106           0 :                      (long) (elapse_t.tv_usec - Save_t.tv_usec));
    5107           0 :     appendStringInfo(&str,
    5108             :                      "!\t[%ld.%06ld s user, %ld.%06ld s system total]\n",
    5109           0 :                      (long) user.tv_sec,
    5110           0 :                      (long) user.tv_usec,
    5111           0 :                      (long) sys.tv_sec,
    5112           0 :                      (long) sys.tv_usec);
    5113             : #ifndef WIN32
    5114             : 
    5115             :     /*
    5116             :      * The following rusage fields are not defined by POSIX, but they're
    5117             :      * present on all current Unix-like systems so we use them without any
    5118             :      * special checks.  Some of these could be provided in our Windows
    5119             :      * emulation in src/port/win32getrusage.c with more work.
    5120             :      */
    5121           0 :     appendStringInfo(&str,
    5122             :                      "!\t%ld kB max resident size\n",
    5123             : #if defined(__darwin__)
    5124             :     /* in bytes on macOS */
    5125             :                      r.ru_maxrss / 1024
    5126             : #else
    5127             :     /* in kilobytes on most other platforms */
    5128             :                      r.ru_maxrss
    5129             : #endif
    5130             :         );
    5131           0 :     appendStringInfo(&str,
    5132             :                      "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
    5133           0 :                      r.ru_inblock - Save_r.ru_inblock,
    5134             :     /* they only drink coffee at dec */
    5135           0 :                      r.ru_oublock - Save_r.ru_oublock,
    5136             :                      r.ru_inblock, r.ru_oublock);
    5137           0 :     appendStringInfo(&str,
    5138             :                      "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
    5139           0 :                      r.ru_majflt - Save_r.ru_majflt,
    5140           0 :                      r.ru_minflt - Save_r.ru_minflt,
    5141             :                      r.ru_majflt, r.ru_minflt,
    5142           0 :                      r.ru_nswap - Save_r.ru_nswap,
    5143             :                      r.ru_nswap);
    5144           0 :     appendStringInfo(&str,
    5145             :                      "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
    5146           0 :                      r.ru_nsignals - Save_r.ru_nsignals,
    5147             :                      r.ru_nsignals,
    5148           0 :                      r.ru_msgrcv - Save_r.ru_msgrcv,
    5149           0 :                      r.ru_msgsnd - Save_r.ru_msgsnd,
    5150             :                      r.ru_msgrcv, r.ru_msgsnd);
    5151           0 :     appendStringInfo(&str,
    5152             :                      "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
    5153           0 :                      r.ru_nvcsw - Save_r.ru_nvcsw,
    5154           0 :                      r.ru_nivcsw - Save_r.ru_nivcsw,
    5155             :                      r.ru_nvcsw, r.ru_nivcsw);
    5156             : #endif                          /* !WIN32 */
    5157             : 
    5158             :     /* remove trailing newline */
    5159           0 :     if (str.data[str.len - 1] == '\n')
    5160           0 :         str.data[--str.len] = '\0';
    5161             : 
    5162           0 :     ereport(LOG,
    5163             :             (errmsg_internal("%s", title),
    5164             :              errdetail_internal("%s", str.data)));
    5165             : 
    5166           0 :     pfree(str.data);
    5167           0 : }
    5168             : 
    5169             : /*
    5170             :  * on_proc_exit handler to log end of session
    5171             :  */
    5172             : static void
    5173          80 : log_disconnections(int code, Datum arg)
    5174             : {
    5175          80 :     Port       *port = MyProcPort;
    5176             :     long        secs;
    5177             :     int         usecs;
    5178             :     int         msecs;
    5179             :     int         hours,
    5180             :                 minutes,
    5181             :                 seconds;
    5182             : 
    5183          80 :     TimestampDifference(MyStartTimestamp,
    5184             :                         GetCurrentTimestamp(),
    5185             :                         &secs, &usecs);
    5186          80 :     msecs = usecs / 1000;
    5187             : 
    5188          80 :     hours = secs / SECS_PER_HOUR;
    5189          80 :     secs %= SECS_PER_HOUR;
    5190          80 :     minutes = secs / SECS_PER_MINUTE;
    5191          80 :     seconds = secs % SECS_PER_MINUTE;
    5192             : 
    5193          80 :     ereport(LOG,
    5194             :             (errmsg("disconnection: session time: %d:%02d:%02d.%03d "
    5195             :                     "user=%s database=%s host=%s%s%s",
    5196             :                     hours, minutes, seconds, msecs,
    5197             :                     port->user_name, port->database_name, port->remote_host,
    5198             :                     port->remote_port[0] ? " port=" : "", port->remote_port)));
    5199          80 : }
    5200             : 
    5201             : /*
    5202             :  * Start statement timeout timer, if enabled.
    5203             :  *
    5204             :  * If there's already a timeout running, don't restart the timer.  That
    5205             :  * enables compromises between accuracy of timeouts and cost of starting a
    5206             :  * timeout.
    5207             :  */
    5208             : static void
    5209     1482082 : enable_statement_timeout(void)
    5210             : {
    5211             :     /* must be within an xact */
    5212             :     Assert(xact_started);
    5213             : 
    5214     1482082 :     if (StatementTimeout > 0
    5215         104 :         && (StatementTimeout < TransactionTimeout || TransactionTimeout == 0))
    5216             :     {
    5217         104 :         if (!get_timeout_active(STATEMENT_TIMEOUT))
    5218          40 :             enable_timeout_after(STATEMENT_TIMEOUT, StatementTimeout);
    5219             :     }
    5220             :     else
    5221             :     {
    5222     1481978 :         if (get_timeout_active(STATEMENT_TIMEOUT))
    5223           0 :             disable_timeout(STATEMENT_TIMEOUT, false);
    5224             :     }
    5225     1482082 : }
    5226             : 
    5227             : /*
    5228             :  * Disable statement timeout, if active.
    5229             :  */
    5230             : static void
    5231     1366610 : disable_statement_timeout(void)
    5232             : {
    5233     1366610 :     if (get_timeout_active(STATEMENT_TIMEOUT))
    5234          24 :         disable_timeout(STATEMENT_TIMEOUT, false);
    5235     1366610 : }

Generated by: LCOV version 1.14