LCOV - code coverage report
Current view: top level - src/bin/psql - common.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 728 968 75.2 %
Date: 2025-04-01 14:15:22 Functions: 37 40 92.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * psql - the PostgreSQL interactive terminal
       3             :  *
       4             :  * Copyright (c) 2000-2025, PostgreSQL Global Development Group
       5             :  *
       6             :  * src/bin/psql/common.c
       7             :  */
       8             : #include "postgres_fe.h"
       9             : 
      10             : #include <ctype.h>
      11             : #include <limits.h>
      12             : #include <math.h>
      13             : #include <pwd.h>
      14             : #include <signal.h>
      15             : #ifndef WIN32
      16             : #include <unistd.h>               /* for write() */
      17             : #else
      18             : #include <io.h>                   /* for _write() */
      19             : #include <win32.h>
      20             : #endif
      21             : 
      22             : #include "command.h"
      23             : #include "common.h"
      24             : #include "common/logging.h"
      25             : #include "copy.h"
      26             : #include "crosstabview.h"
      27             : #include "fe_utils/cancel.h"
      28             : #include "fe_utils/mbprint.h"
      29             : #include "fe_utils/string_utils.h"
      30             : #include "portability/instr_time.h"
      31             : #include "settings.h"
      32             : 
      33             : static bool DescribeQuery(const char *query, double *elapsed_msec);
      34             : static int  ExecQueryAndProcessResults(const char *query,
      35             :                                        double *elapsed_msec,
      36             :                                        bool *svpt_gone_p,
      37             :                                        bool is_watch,
      38             :                                        int min_rows,
      39             :                                        const printQueryOpt *opt,
      40             :                                        FILE *printQueryFout);
      41             : static bool command_no_begin(const char *query);
      42             : 
      43             : 
      44             : /*
      45             :  * openQueryOutputFile --- attempt to open a query output file
      46             :  *
      47             :  * fname == NULL selects stdout, else an initial '|' selects a pipe,
      48             :  * else plain file.
      49             :  *
      50             :  * Returns output file pointer into *fout, and is-a-pipe flag into *is_pipe.
      51             :  * Caller is responsible for adjusting SIGPIPE state if it's a pipe.
      52             :  *
      53             :  * On error, reports suitable error message and returns false.
      54             :  */
      55             : bool
      56       19238 : openQueryOutputFile(const char *fname, FILE **fout, bool *is_pipe)
      57             : {
      58       19238 :     if (!fname || fname[0] == '\0')
      59             :     {
      60       19188 :         *fout = stdout;
      61       19188 :         *is_pipe = false;
      62             :     }
      63          50 :     else if (*fname == '|')
      64             :     {
      65           8 :         fflush(NULL);
      66           8 :         *fout = popen(fname + 1, "w");
      67           8 :         *is_pipe = true;
      68             :     }
      69             :     else
      70             :     {
      71          42 :         *fout = fopen(fname, "w");
      72          42 :         *is_pipe = false;
      73             :     }
      74             : 
      75       19238 :     if (*fout == NULL)
      76             :     {
      77           0 :         pg_log_error("%s: %m", fname);
      78           0 :         return false;
      79             :     }
      80             : 
      81       19238 :     return true;
      82             : }
      83             : 
      84             : /*
      85             :  * Check if an output stream for \g needs to be opened, and if yes,
      86             :  * open it and update the caller's gfile_fout and is_pipe state variables.
      87             :  * Return true if OK, false if an error occurred.
      88             :  */
      89             : static bool
      90      132758 : SetupGOutput(FILE **gfile_fout, bool *is_pipe)
      91             : {
      92             :     /* If there is a \g file or program, and it's not already open, open it */
      93      132758 :     if (pset.gfname != NULL && *gfile_fout == NULL)
      94             :     {
      95          32 :         if (openQueryOutputFile(pset.gfname, gfile_fout, is_pipe))
      96             :         {
      97          32 :             if (*is_pipe)
      98           8 :                 disable_sigpipe_trap();
      99             :         }
     100             :         else
     101           0 :             return false;
     102             :     }
     103      132758 :     return true;
     104             : }
     105             : 
     106             : /*
     107             :  * Close the output stream for \g, if we opened it.
     108             :  */
     109             : static void
     110      339394 : CloseGOutput(FILE *gfile_fout, bool is_pipe)
     111             : {
     112      339394 :     if (gfile_fout)
     113             :     {
     114          32 :         if (is_pipe)
     115             :         {
     116           8 :             SetShellResultVariables(pclose(gfile_fout));
     117           8 :             restore_sigpipe_trap();
     118             :         }
     119             :         else
     120          24 :             fclose(gfile_fout);
     121             :     }
     122      339394 : }
     123             : 
     124             : /*
     125             :  * Reset pset pipeline state
     126             :  */
     127             : static void
     128           0 : pipelineReset(void)
     129             : {
     130           0 :     pset.piped_syncs = 0;
     131           0 :     pset.piped_commands = 0;
     132           0 :     pset.available_results = 0;
     133           0 :     pset.requested_results = 0;
     134           0 : }
     135             : 
     136             : /*
     137             :  * setQFout
     138             :  * -- handler for -o command line option and \o command
     139             :  *
     140             :  * On success, updates pset with the new output file and returns true.
     141             :  * On failure, returns false without changing pset state.
     142             :  */
     143             : bool
     144       19206 : setQFout(const char *fname)
     145             : {
     146             :     FILE       *fout;
     147             :     bool        is_pipe;
     148             : 
     149             :     /* First make sure we can open the new output file/pipe */
     150       19206 :     if (!openQueryOutputFile(fname, &fout, &is_pipe))
     151           0 :         return false;
     152             : 
     153             :     /* Close old file/pipe */
     154       19206 :     if (pset.queryFout && pset.queryFout != stdout && pset.queryFout != stderr)
     155             :     {
     156          18 :         if (pset.queryFoutPipe)
     157           0 :             SetShellResultVariables(pclose(pset.queryFout));
     158             :         else
     159          18 :             fclose(pset.queryFout);
     160             :     }
     161             : 
     162       19206 :     pset.queryFout = fout;
     163       19206 :     pset.queryFoutPipe = is_pipe;
     164             : 
     165             :     /* Adjust SIGPIPE handling appropriately: ignore signal if is_pipe */
     166       19206 :     set_sigpipe_trap_state(is_pipe);
     167       19206 :     restore_sigpipe_trap();
     168             : 
     169       19206 :     return true;
     170             : }
     171             : 
     172             : 
     173             : /*
     174             :  * Variable-fetching callback for flex lexer
     175             :  *
     176             :  * If the specified variable exists, return its value as a string (malloc'd
     177             :  * and expected to be freed by the caller); else return NULL.
     178             :  *
     179             :  * If "quote" isn't PQUOTE_PLAIN, then return the value suitably quoted and
     180             :  * escaped for the specified quoting requirement.  (Failure in escaping
     181             :  * should lead to printing an error and returning NULL.)
     182             :  *
     183             :  * "passthrough" is the pointer previously given to psql_scan_set_passthrough.
     184             :  * In psql, passthrough points to a ConditionalStack, which we check to
     185             :  * determine whether variable expansion is allowed.
     186             :  */
     187             : char *
     188        3898 : psql_get_variable(const char *varname, PsqlScanQuoteType quote,
     189             :                   void *passthrough)
     190             : {
     191        3898 :     char       *result = NULL;
     192             :     const char *value;
     193             : 
     194             :     /* In an inactive \if branch, suppress all variable substitutions */
     195        3898 :     if (passthrough && !conditional_active((ConditionalStack) passthrough))
     196          72 :         return NULL;
     197             : 
     198        3826 :     value = GetVariable(pset.vars, varname);
     199        3826 :     if (!value)
     200         464 :         return NULL;
     201             : 
     202        3362 :     switch (quote)
     203             :     {
     204        2488 :         case PQUOTE_PLAIN:
     205        2488 :             result = pg_strdup(value);
     206        2488 :             break;
     207         874 :         case PQUOTE_SQL_LITERAL:
     208             :         case PQUOTE_SQL_IDENT:
     209             :             {
     210             :                 /*
     211             :                  * For these cases, we use libpq's quoting functions, which
     212             :                  * assume the string is in the connection's client encoding.
     213             :                  */
     214             :                 char       *escaped_value;
     215             : 
     216         874 :                 if (!pset.db)
     217             :                 {
     218           0 :                     pg_log_error("cannot escape without active connection");
     219           0 :                     return NULL;
     220             :                 }
     221             : 
     222         874 :                 if (quote == PQUOTE_SQL_LITERAL)
     223             :                     escaped_value =
     224         848 :                         PQescapeLiteral(pset.db, value, strlen(value));
     225             :                 else
     226             :                     escaped_value =
     227          26 :                         PQescapeIdentifier(pset.db, value, strlen(value));
     228             : 
     229         874 :                 if (escaped_value == NULL)
     230             :                 {
     231           0 :                     const char *error = PQerrorMessage(pset.db);
     232             : 
     233           0 :                     pg_log_info("%s", error);
     234           0 :                     return NULL;
     235             :                 }
     236             : 
     237             :                 /*
     238             :                  * Rather than complicate the lexer's API with a notion of
     239             :                  * which free() routine to use, just pay the price of an extra
     240             :                  * strdup().
     241             :                  */
     242         874 :                 result = pg_strdup(escaped_value);
     243         874 :                 PQfreemem(escaped_value);
     244         874 :                 break;
     245             :             }
     246           0 :         case PQUOTE_SHELL_ARG:
     247             :             {
     248             :                 /*
     249             :                  * For this we use appendShellStringNoError, which is
     250             :                  * encoding-agnostic, which is fine since the shell probably
     251             :                  * is too.  In any case, the only special character is "'",
     252             :                  * which is not known to appear in valid multibyte characters.
     253             :                  */
     254             :                 PQExpBufferData buf;
     255             : 
     256           0 :                 initPQExpBuffer(&buf);
     257           0 :                 if (!appendShellStringNoError(&buf, value))
     258             :                 {
     259           0 :                     pg_log_error("shell command argument contains a newline or carriage return: \"%s\"",
     260             :                                  value);
     261           0 :                     free(buf.data);
     262           0 :                     return NULL;
     263             :                 }
     264           0 :                 result = buf.data;
     265           0 :                 break;
     266             :             }
     267             : 
     268             :             /* No default: we want a compiler warning for missing cases */
     269             :     }
     270             : 
     271        3362 :     return result;
     272             : }
     273             : 
     274             : 
     275             : /*
     276             :  * for backend Notice messages (INFO, WARNING, etc)
     277             :  */
     278             : void
     279      154034 : NoticeProcessor(void *arg, const char *message)
     280             : {
     281             :     (void) arg;                 /* not used */
     282      154034 :     pg_log_info("%s", message);
     283      154034 : }
     284             : 
     285             : 
     286             : 
     287             : /*
     288             :  * Code to support query cancellation
     289             :  *
     290             :  * Before we start a query, we enable the SIGINT signal catcher to send a
     291             :  * cancel request to the backend.
     292             :  *
     293             :  * SIGINT is supposed to abort all long-running psql operations, not only
     294             :  * database queries.  In most places, this is accomplished by checking
     295             :  * cancel_pressed during long-running loops.  However, that won't work when
     296             :  * blocked on user input (in readline() or fgets()).  In those places, we
     297             :  * set sigint_interrupt_enabled true while blocked, instructing the signal
     298             :  * catcher to longjmp through sigint_interrupt_jmp.  We assume readline and
     299             :  * fgets are coded to handle possible interruption.
     300             :  *
     301             :  * On Windows, currently this does not work, so control-C is less useful
     302             :  * there.
     303             :  */
     304             : volatile sig_atomic_t sigint_interrupt_enabled = false;
     305             : 
     306             : sigjmp_buf  sigint_interrupt_jmp;
     307             : 
     308             : static void
     309           2 : psql_cancel_callback(void)
     310             : {
     311             : #ifndef WIN32
     312             :     /* if we are waiting for input, longjmp out of it */
     313           2 :     if (sigint_interrupt_enabled)
     314             :     {
     315           0 :         sigint_interrupt_enabled = false;
     316           0 :         siglongjmp(sigint_interrupt_jmp, 1);
     317             :     }
     318             : #endif
     319             : 
     320             :     /* else, set cancel flag to stop any long-running loops */
     321           2 :     cancel_pressed = true;
     322           2 : }
     323             : 
     324             : void
     325       19190 : psql_setup_cancel_handler(void)
     326             : {
     327       19190 :     setup_cancel_handler(psql_cancel_callback);
     328       19190 : }
     329             : 
     330             : 
     331             : /* ConnectionUp
     332             :  *
     333             :  * Returns whether our backend connection is still there.
     334             :  */
     335             : static bool
     336      380592 : ConnectionUp(void)
     337             : {
     338      380592 :     return PQstatus(pset.db) != CONNECTION_BAD;
     339             : }
     340             : 
     341             : 
     342             : 
     343             : /* CheckConnection
     344             :  *
     345             :  * Verify that we still have a good connection to the backend, and if not,
     346             :  * see if it can be restored.
     347             :  *
     348             :  * Returns true if either the connection was still there, or it could be
     349             :  * restored successfully; false otherwise.  If, however, there was no
     350             :  * connection and the session is non-interactive, this will exit the program
     351             :  * with a code of EXIT_BADCONN.
     352             :  */
     353             : static bool
     354      380592 : CheckConnection(void)
     355             : {
     356             :     bool        OK;
     357             : 
     358      380592 :     OK = ConnectionUp();
     359      380592 :     if (!OK)
     360             :     {
     361          20 :         if (!pset.cur_cmd_interactive)
     362             :         {
     363          20 :             pg_log_error("connection to server was lost");
     364          20 :             exit(EXIT_BADCONN);
     365             :         }
     366             : 
     367           0 :         fprintf(stderr, _("The connection to the server was lost. Attempting reset: "));
     368           0 :         PQreset(pset.db);
     369           0 :         pipelineReset();
     370           0 :         OK = ConnectionUp();
     371           0 :         if (!OK)
     372             :         {
     373           0 :             fprintf(stderr, _("Failed.\n"));
     374             : 
     375             :             /*
     376             :              * Transition to having no connection; but stash away the failed
     377             :              * connection so that we can still refer to its parameters in a
     378             :              * later \connect attempt.  Keep the state cleanup here in sync
     379             :              * with do_connect().
     380             :              */
     381           0 :             if (pset.dead_conn)
     382           0 :                 PQfinish(pset.dead_conn);
     383           0 :             pset.dead_conn = pset.db;
     384           0 :             pset.db = NULL;
     385           0 :             ResetCancelConn();
     386           0 :             UnsyncVariables();
     387             :         }
     388             :         else
     389             :         {
     390           0 :             fprintf(stderr, _("Succeeded.\n"));
     391             : 
     392             :             /*
     393             :              * Re-sync, just in case anything changed.  Keep this in sync with
     394             :              * do_connect().
     395             :              */
     396           0 :             SyncVariables();
     397           0 :             connection_warnings(false); /* Must be after SyncVariables */
     398             :         }
     399             :     }
     400             : 
     401      380572 :     return OK;
     402             : }
     403             : 
     404             : 
     405             : 
     406             : 
     407             : /*
     408             :  * AcceptResult
     409             :  *
     410             :  * Checks whether a result is valid, giving an error message if necessary;
     411             :  * and ensures that the connection to the backend is still up.
     412             :  *
     413             :  * Returns true for valid result, false for error state.
     414             :  */
     415             : static bool
     416      378358 : AcceptResult(const PGresult *result, bool show_error)
     417             : {
     418             :     bool        OK;
     419             : 
     420      378358 :     if (!result)
     421           0 :         OK = false;
     422             :     else
     423      378358 :         switch (PQresultStatus(result))
     424             :         {
     425      337208 :             case PGRES_COMMAND_OK:
     426             :             case PGRES_TUPLES_OK:
     427             :             case PGRES_TUPLES_CHUNK:
     428             :             case PGRES_EMPTY_QUERY:
     429             :             case PGRES_COPY_IN:
     430             :             case PGRES_COPY_OUT:
     431             :             case PGRES_PIPELINE_SYNC:
     432             :                 /* Fine, do nothing */
     433      337208 :                 OK = true;
     434      337208 :                 break;
     435             : 
     436       41148 :             case PGRES_PIPELINE_ABORTED:
     437             :             case PGRES_BAD_RESPONSE:
     438             :             case PGRES_NONFATAL_ERROR:
     439             :             case PGRES_FATAL_ERROR:
     440       41148 :                 OK = false;
     441       41148 :                 break;
     442             : 
     443           2 :             default:
     444           2 :                 OK = false;
     445           2 :                 pg_log_error("unexpected PQresultStatus: %d",
     446             :                              PQresultStatus(result));
     447           2 :                 break;
     448             :         }
     449             : 
     450      378358 :     if (!OK && show_error)
     451             :     {
     452           6 :         const char *error = PQerrorMessage(pset.db);
     453             : 
     454           6 :         if (strlen(error))
     455           6 :             pg_log_info("%s", error);
     456             : 
     457           6 :         CheckConnection();
     458             :     }
     459             : 
     460      378358 :     return OK;
     461             : }
     462             : 
     463             : 
     464             : /*
     465             :  * Set special variables from a query result
     466             :  * - ERROR: true/false, whether an error occurred on this query
     467             :  * - SQLSTATE: code of error, or "00000" if no error, or "" if unknown
     468             :  * - ROW_COUNT: how many rows were returned or affected, or "0"
     469             :  * - LAST_ERROR_SQLSTATE: same for last error
     470             :  * - LAST_ERROR_MESSAGE: message of last error
     471             :  *
     472             :  * Note: current policy is to apply this only to the results of queries
     473             :  * entered by the user, not queries generated by slash commands.
     474             :  */
     475             : static void
     476      339456 : SetResultVariables(PGresult *result, bool success)
     477             : {
     478      339456 :     if (success)
     479             :     {
     480      297994 :         const char *ntuples = PQcmdTuples(result);
     481             : 
     482      297994 :         SetVariable(pset.vars, "ERROR", "false");
     483      297994 :         SetVariable(pset.vars, "SQLSTATE", "00000");
     484      297994 :         SetVariable(pset.vars, "ROW_COUNT", *ntuples ? ntuples : "0");
     485             :     }
     486             :     else
     487             :     {
     488       41462 :         const char *code = PQresultErrorField(result, PG_DIAG_SQLSTATE);
     489       41462 :         const char *mesg = PQresultErrorField(result, PG_DIAG_MESSAGE_PRIMARY);
     490             : 
     491       41462 :         SetVariable(pset.vars, "ERROR", "true");
     492             : 
     493             :         /*
     494             :          * If there is no SQLSTATE code, use an empty string.  This can happen
     495             :          * for libpq-detected errors (e.g., lost connection, ENOMEM).
     496             :          */
     497       41462 :         if (code == NULL)
     498         154 :             code = "";
     499       41462 :         SetVariable(pset.vars, "SQLSTATE", code);
     500       41462 :         SetVariable(pset.vars, "ROW_COUNT", "0");
     501       41462 :         SetVariable(pset.vars, "LAST_ERROR_SQLSTATE", code);
     502       41462 :         SetVariable(pset.vars, "LAST_ERROR_MESSAGE", mesg ? mesg : "");
     503             :     }
     504      339456 : }
     505             : 
     506             : 
     507             : /*
     508             :  * Set special variables from a shell command result
     509             :  * - SHELL_ERROR: true/false, whether command returned exit code 0
     510             :  * - SHELL_EXIT_CODE: exit code according to shell conventions
     511             :  *
     512             :  * The argument is a wait status as returned by wait(2) or waitpid(2),
     513             :  * which also applies to pclose(3) and system(3).
     514             :  */
     515             : void
     516           8 : SetShellResultVariables(int wait_result)
     517             : {
     518             :     char        buf[32];
     519             : 
     520           8 :     SetVariable(pset.vars, "SHELL_ERROR",
     521             :                 (wait_result == 0) ? "false" : "true");
     522           8 :     snprintf(buf, sizeof(buf), "%d", wait_result_to_exit_code(wait_result));
     523           8 :     SetVariable(pset.vars, "SHELL_EXIT_CODE", buf);
     524           8 : }
     525             : 
     526             : 
     527             : /*
     528             :  * Set special pipeline variables
     529             :  * - PIPELINE_SYNC_COUNT: The number of piped syncs
     530             :  * - PIPELINE_COMMAND_COUNT: The number of piped commands
     531             :  * - PIPELINE_RESULT_COUNT: The number of results available to read
     532             :  */
     533             : static void
     534      340882 : SetPipelineVariables(void)
     535             : {
     536             :     char        buf[32];
     537             : 
     538      340882 :     snprintf(buf, sizeof(buf), "%d", pset.piped_syncs);
     539      340882 :     SetVariable(pset.vars, "PIPELINE_SYNC_COUNT", buf);
     540      340882 :     snprintf(buf, sizeof(buf), "%d", pset.piped_commands);
     541      340882 :     SetVariable(pset.vars, "PIPELINE_COMMAND_COUNT", buf);
     542      340882 :     snprintf(buf, sizeof(buf), "%d", pset.available_results);
     543      340882 :     SetVariable(pset.vars, "PIPELINE_RESULT_COUNT", buf);
     544      340882 : }
     545             : 
     546             : 
     547             : /*
     548             :  * ClearOrSaveResult
     549             :  *
     550             :  * If the result represents an error, remember it for possible display by
     551             :  * \errverbose.  Otherwise, just PQclear() it.
     552             :  *
     553             :  * Note: current policy is to apply this to the results of all queries,
     554             :  * including "back door" queries, for debugging's sake.  It's OK to use
     555             :  * PQclear() directly on results known to not be error results, however.
     556             :  */
     557             : static void
     558      342224 : ClearOrSaveResult(PGresult *result)
     559             : {
     560      342224 :     if (result)
     561             :     {
     562      341602 :         switch (PQresultStatus(result))
     563             :         {
     564       41316 :             case PGRES_NONFATAL_ERROR:
     565             :             case PGRES_FATAL_ERROR:
     566       41316 :                 PQclear(pset.last_error_result);
     567       41316 :                 pset.last_error_result = result;
     568       41316 :                 break;
     569             : 
     570      300286 :             default:
     571      300286 :                 PQclear(result);
     572      300286 :                 break;
     573             :         }
     574         622 :     }
     575      342224 : }
     576             : 
     577             : 
     578             : /*
     579             :  * Consume all results
     580             :  */
     581             : static void
     582           0 : ClearOrSaveAllResults(void)
     583             : {
     584             :     PGresult   *result;
     585             : 
     586           0 :     while ((result = PQgetResult(pset.db)) != NULL)
     587           0 :         ClearOrSaveResult(result);
     588           0 : }
     589             : 
     590             : 
     591             : /*
     592             :  * Print microtiming output.  Always print raw milliseconds; if the interval
     593             :  * is >= 1 second, also break it down into days/hours/minutes/seconds.
     594             :  */
     595             : static void
     596           4 : PrintTiming(double elapsed_msec)
     597             : {
     598             :     double      seconds;
     599             :     double      minutes;
     600             :     double      hours;
     601             :     double      days;
     602             : 
     603           4 :     if (elapsed_msec < 1000.0)
     604             :     {
     605             :         /* This is the traditional (pre-v10) output format */
     606           4 :         printf(_("Time: %.3f ms\n"), elapsed_msec);
     607           4 :         return;
     608             :     }
     609             : 
     610             :     /*
     611             :      * Note: we could print just seconds, in a format like %06.3f, when the
     612             :      * total is less than 1min.  But that's hard to interpret unless we tack
     613             :      * on "s" or otherwise annotate it.  Forcing the display to include
     614             :      * minutes seems like a better solution.
     615             :      */
     616           0 :     seconds = elapsed_msec / 1000.0;
     617           0 :     minutes = floor(seconds / 60.0);
     618           0 :     seconds -= 60.0 * minutes;
     619           0 :     if (minutes < 60.0)
     620             :     {
     621           0 :         printf(_("Time: %.3f ms (%02d:%06.3f)\n"),
     622             :                elapsed_msec, (int) minutes, seconds);
     623           0 :         return;
     624             :     }
     625             : 
     626           0 :     hours = floor(minutes / 60.0);
     627           0 :     minutes -= 60.0 * hours;
     628           0 :     if (hours < 24.0)
     629             :     {
     630           0 :         printf(_("Time: %.3f ms (%02d:%02d:%06.3f)\n"),
     631             :                elapsed_msec, (int) hours, (int) minutes, seconds);
     632           0 :         return;
     633             :     }
     634             : 
     635           0 :     days = floor(hours / 24.0);
     636           0 :     hours -= 24.0 * days;
     637           0 :     printf(_("Time: %.3f ms (%.0f d %02d:%02d:%06.3f)\n"),
     638             :            elapsed_msec, days, (int) hours, (int) minutes, seconds);
     639             : }
     640             : 
     641             : 
     642             : /*
     643             :  * PSQLexec
     644             :  *
     645             :  * This is the way to send "backdoor" queries (those not directly entered
     646             :  * by the user). It is subject to -E but not -e.
     647             :  *
     648             :  * Caller is responsible for handling the ensuing processing if a COPY
     649             :  * command is sent.
     650             :  *
     651             :  * Note: we don't bother to check PQclientEncoding; it is assumed that no
     652             :  * caller uses this path to issue "SET CLIENT_ENCODING".
     653             :  */
     654             : PGresult *
     655       36482 : PSQLexec(const char *query)
     656             : {
     657             :     PGresult   *res;
     658             : 
     659       36482 :     if (!pset.db)
     660             :     {
     661           0 :         pg_log_error("You are currently not connected to a database.");
     662           0 :         return NULL;
     663             :     }
     664             : 
     665       36482 :     if (pset.echo_hidden != PSQL_ECHO_HIDDEN_OFF)
     666             :     {
     667           0 :         printf(_("/******** QUERY *********/\n"
     668             :                  "%s\n"
     669             :                  "/************************/\n\n"), query);
     670           0 :         fflush(stdout);
     671           0 :         if (pset.logfile)
     672             :         {
     673           0 :             fprintf(pset.logfile,
     674           0 :                     _("/******** QUERY *********/\n"
     675             :                       "%s\n"
     676             :                       "/************************/\n\n"), query);
     677           0 :             fflush(pset.logfile);
     678             :         }
     679             : 
     680           0 :         if (pset.echo_hidden == PSQL_ECHO_HIDDEN_NOEXEC)
     681           0 :             return NULL;
     682             :     }
     683             : 
     684       36482 :     SetCancelConn(pset.db);
     685             : 
     686       36482 :     res = PQexec(pset.db, query);
     687             : 
     688       36482 :     ResetCancelConn();
     689             : 
     690       36482 :     if (!AcceptResult(res, true))
     691             :     {
     692           0 :         ClearOrSaveResult(res);
     693           0 :         res = NULL;
     694             :     }
     695             : 
     696       36482 :     return res;
     697             : }
     698             : 
     699             : 
     700             : /*
     701             :  * PSQLexecWatch
     702             :  *
     703             :  * This function is used for \watch command to send the query to
     704             :  * the server and print out the result.
     705             :  *
     706             :  * Returns 1 if the query executed successfully, 0 if it cannot be repeated,
     707             :  * e.g., because of the interrupt, -1 on error.
     708             :  */
     709             : int
     710          42 : PSQLexecWatch(const char *query, const printQueryOpt *opt, FILE *printQueryFout, int min_rows)
     711             : {
     712          42 :     bool        timing = pset.timing;
     713          42 :     double      elapsed_msec = 0;
     714             :     int         res;
     715             : 
     716          42 :     if (!pset.db)
     717             :     {
     718           0 :         pg_log_error("You are currently not connected to a database.");
     719           0 :         return 0;
     720             :     }
     721             : 
     722          42 :     SetCancelConn(pset.db);
     723             : 
     724          42 :     res = ExecQueryAndProcessResults(query, &elapsed_msec, NULL, true, min_rows, opt, printQueryFout);
     725             : 
     726          40 :     ResetCancelConn();
     727             : 
     728             :     /* Possible microtiming output */
     729          40 :     if (timing)
     730           0 :         PrintTiming(elapsed_msec);
     731             : 
     732          40 :     return res;
     733             : }
     734             : 
     735             : 
     736             : /*
     737             :  * PrintNotifications: check for asynchronous notifications, and print them out
     738             :  */
     739             : static void
     740      340928 : PrintNotifications(void)
     741             : {
     742             :     PGnotify   *notify;
     743             : 
     744      340928 :     PQconsumeInput(pset.db);
     745      340932 :     while ((notify = PQnotifies(pset.db)) != NULL)
     746             :     {
     747             :         /* for backward compatibility, only show payload if nonempty */
     748           4 :         if (notify->extra[0])
     749           2 :             fprintf(pset.queryFout, _("Asynchronous notification \"%s\" with payload \"%s\" received from server process with PID %d.\n"),
     750             :                     notify->relname, notify->extra, notify->be_pid);
     751             :         else
     752           2 :             fprintf(pset.queryFout, _("Asynchronous notification \"%s\" received from server process with PID %d.\n"),
     753             :                     notify->relname, notify->be_pid);
     754           4 :         fflush(pset.queryFout);
     755           4 :         PQfreemem(notify);
     756           4 :         PQconsumeInput(pset.db);
     757             :     }
     758      340928 : }
     759             : 
     760             : 
     761             : /*
     762             :  * PrintQueryTuples: assuming query result is OK, print its tuples
     763             :  *
     764             :  * We use the options given by opt unless that's NULL, in which case
     765             :  * we use pset.popt.
     766             :  *
     767             :  * Output is to printQueryFout unless that's NULL, in which case
     768             :  * we use pset.queryFout.
     769             :  *
     770             :  * Returns true if successful, false otherwise.
     771             :  */
     772             : static bool
     773      131766 : PrintQueryTuples(const PGresult *result, const printQueryOpt *opt,
     774             :                  FILE *printQueryFout)
     775             : {
     776      131766 :     bool        ok = true;
     777      131766 :     FILE       *fout = printQueryFout ? printQueryFout : pset.queryFout;
     778             : 
     779      131766 :     printQuery(result, opt ? opt : &pset.popt, fout, false, pset.logfile);
     780      131766 :     fflush(fout);
     781      131766 :     if (ferror(fout))
     782             :     {
     783           0 :         pg_log_error("could not print result table: %m");
     784           0 :         ok = false;
     785             :     }
     786             : 
     787      131766 :     return ok;
     788             : }
     789             : 
     790             : 
     791             : /*
     792             :  * StoreQueryTuple: assuming query result is OK, save data into variables
     793             :  *
     794             :  * Returns true if successful, false otherwise.
     795             :  */
     796             : static bool
     797         744 : StoreQueryTuple(const PGresult *result)
     798             : {
     799         744 :     bool        success = true;
     800             : 
     801         744 :     if (PQntuples(result) < 1)
     802             :     {
     803          18 :         pg_log_error("no rows returned for \\gset");
     804          18 :         success = false;
     805             :     }
     806         726 :     else if (PQntuples(result) > 1)
     807             :     {
     808          12 :         pg_log_error("more than one row returned for \\gset");
     809          12 :         success = false;
     810             :     }
     811             :     else
     812             :     {
     813             :         int         i;
     814             : 
     815        1602 :         for (i = 0; i < PQnfields(result); i++)
     816             :         {
     817         894 :             char       *colname = PQfname(result, i);
     818             :             char       *varname;
     819             :             char       *value;
     820             : 
     821             :             /* concatenate prefix and column name */
     822         894 :             varname = psprintf("%s%s", pset.gset_prefix, colname);
     823             : 
     824         894 :             if (VariableHasHook(pset.vars, varname))
     825             :             {
     826           6 :                 pg_log_warning("attempt to \\gset into specially treated variable \"%s\" ignored",
     827             :                                varname);
     828           6 :                 continue;
     829             :             }
     830             : 
     831         888 :             if (!PQgetisnull(result, 0, i))
     832         876 :                 value = PQgetvalue(result, 0, i);
     833             :             else
     834             :             {
     835             :                 /* for NULL value, unset rather than set the variable */
     836          12 :                 value = NULL;
     837             :             }
     838             : 
     839         888 :             if (!SetVariable(pset.vars, varname, value))
     840             :             {
     841           6 :                 free(varname);
     842           6 :                 success = false;
     843           6 :                 break;
     844             :             }
     845             : 
     846         882 :             free(varname);
     847             :         }
     848             :     }
     849             : 
     850         744 :     return success;
     851             : }
     852             : 
     853             : 
     854             : /*
     855             :  * ExecQueryTuples: assuming query result is OK, execute each query
     856             :  * result field as a SQL statement
     857             :  *
     858             :  * Returns true if successful, false otherwise.
     859             :  */
     860             : static bool
     861          46 : ExecQueryTuples(const PGresult *result)
     862             : {
     863          46 :     bool        success = true;
     864          46 :     int         nrows = PQntuples(result);
     865          46 :     int         ncolumns = PQnfields(result);
     866             :     int         r,
     867             :                 c;
     868             : 
     869             :     /*
     870             :      * We must turn off gexec_flag to avoid infinite recursion.
     871             :      */
     872          46 :     pset.gexec_flag = false;
     873             : 
     874         472 :     for (r = 0; r < nrows; r++)
     875             :     {
     876         870 :         for (c = 0; c < ncolumns; c++)
     877             :         {
     878         444 :             if (!PQgetisnull(result, r, c))
     879             :             {
     880         438 :                 const char *query = PQgetvalue(result, r, c);
     881             : 
     882             :                 /* Abandon execution if cancel_pressed */
     883         438 :                 if (cancel_pressed)
     884           0 :                     goto loop_exit;
     885             : 
     886             :                 /*
     887             :                  * ECHO_ALL mode should echo these queries, but SendQuery
     888             :                  * assumes that MainLoop did that, so we have to do it here.
     889             :                  */
     890         438 :                 if (pset.echo == PSQL_ECHO_ALL && !pset.singlestep)
     891             :                 {
     892         430 :                     puts(query);
     893         430 :                     fflush(stdout);
     894             :                 }
     895             : 
     896         438 :                 if (!SendQuery(query))
     897             :                 {
     898             :                     /* Error - abandon execution if ON_ERROR_STOP */
     899           6 :                     success = false;
     900           6 :                     if (pset.on_error_stop)
     901           0 :                         goto loop_exit;
     902             :                 }
     903             :             }
     904             :         }
     905             :     }
     906             : 
     907          46 : loop_exit:
     908             : 
     909             :     /*
     910             :      * Restore state.  We know gexec_flag was on, else we'd not be here. (We
     911             :      * also know it'll get turned off at end of command, but that's not ours
     912             :      * to do here.)
     913             :      */
     914          46 :     pset.gexec_flag = true;
     915             : 
     916             :     /* Return true if all queries were successful */
     917          46 :     return success;
     918             : }
     919             : 
     920             : 
     921             : /*
     922             :  * Marshal the COPY data.  Either path will get the
     923             :  * connection out of its COPY state, then call PQresultStatus()
     924             :  * once and report any error.  Return whether all was ok.
     925             :  *
     926             :  * For COPY OUT, direct the output to copystream, or discard if that's NULL.
     927             :  * For COPY IN, use pset.copyStream as data source if it's set,
     928             :  * otherwise cur_cmd_source.
     929             :  *
     930             :  * Update *resultp if further processing is necessary; set to NULL otherwise.
     931             :  * Return a result when queryFout can safely output a result status: on COPY
     932             :  * IN, or on COPY OUT if written to something other than pset.queryFout.
     933             :  * Returning NULL prevents the command status from being printed, which we
     934             :  * want if the status line doesn't get taken as part of the COPY data.
     935             :  */
     936             : static bool
     937        1520 : HandleCopyResult(PGresult **resultp, FILE *copystream)
     938             : {
     939             :     bool        success;
     940             :     PGresult   *copy_result;
     941        1520 :     ExecStatusType result_status = PQresultStatus(*resultp);
     942             : 
     943             :     Assert(result_status == PGRES_COPY_OUT ||
     944             :            result_status == PGRES_COPY_IN);
     945             : 
     946        1520 :     SetCancelConn(pset.db);
     947             : 
     948        1520 :     if (result_status == PGRES_COPY_OUT)
     949             :     {
     950         570 :         success = handleCopyOut(pset.db,
     951             :                                 copystream,
     952             :                                 &copy_result)
     953         570 :             && (copystream != NULL);
     954             : 
     955             :         /*
     956             :          * Suppress status printing if the report would go to the same place
     957             :          * as the COPY data just went.  Note this doesn't prevent error
     958             :          * reporting, since handleCopyOut did that.
     959             :          */
     960         570 :         if (copystream == pset.queryFout)
     961             :         {
     962         544 :             PQclear(copy_result);
     963         544 :             copy_result = NULL;
     964             :         }
     965             :     }
     966             :     else
     967             :     {
     968             :         /* COPY IN */
     969             :         /* Ignore the copystream argument passed to the function */
     970         950 :         copystream = pset.copyStream ? pset.copyStream : pset.cur_cmd_source;
     971         950 :         success = handleCopyIn(pset.db,
     972             :                                copystream,
     973         950 :                                PQbinaryTuples(*resultp),
     974             :                                &copy_result);
     975             :     }
     976        1520 :     ResetCancelConn();
     977             : 
     978             :     /*
     979             :      * Replace the PGRES_COPY_OUT/IN result with COPY command's exit status,
     980             :      * or with NULL if we want to suppress printing anything.
     981             :      */
     982        1520 :     PQclear(*resultp);
     983        1520 :     *resultp = copy_result;
     984             : 
     985        1520 :     return success;
     986             : }
     987             : 
     988             : /*
     989             :  * PrintQueryStatus: report command status as required
     990             :  */
     991             : static void
     992      299296 : PrintQueryStatus(PGresult *result, FILE *printQueryFout)
     993             : {
     994             :     char        buf[16];
     995      299296 :     const char *cmdstatus = PQcmdStatus(result);
     996      299296 :     FILE       *fout = printQueryFout ? printQueryFout : pset.queryFout;
     997             : 
     998             :     /* Do nothing if it's a TUPLES_OK result that isn't from RETURNING */
     999      299296 :     if (PQresultStatus(result) == PGRES_TUPLES_OK)
    1000             :     {
    1001      132748 :         if (!(strncmp(cmdstatus, "INSERT", 6) == 0 ||
    1002      132288 :               strncmp(cmdstatus, "UPDATE", 6) == 0 ||
    1003      131764 :               strncmp(cmdstatus, "DELETE", 6) == 0 ||
    1004      131550 :               strncmp(cmdstatus, "MERGE", 5) == 0))
    1005      131412 :             return;
    1006             :     }
    1007             : 
    1008      167884 :     if (!pset.quiet)
    1009             :     {
    1010         874 :         if (pset.popt.topt.format == PRINT_HTML)
    1011             :         {
    1012           0 :             fputs("<p>", fout);
    1013           0 :             html_escaped_print(cmdstatus, fout);
    1014           0 :             fputs("</p>\n", fout);
    1015             :         }
    1016             :         else
    1017         874 :             fprintf(fout, "%s\n", cmdstatus);
    1018         874 :         fflush(fout);
    1019             :     }
    1020             : 
    1021      167884 :     if (pset.logfile)
    1022           0 :         fprintf(pset.logfile, "%s\n", cmdstatus);
    1023             : 
    1024      167884 :     snprintf(buf, sizeof(buf), "%u", (unsigned int) PQoidValue(result));
    1025      167884 :     SetVariable(pset.vars, "LASTOID", buf);
    1026             : }
    1027             : 
    1028             : 
    1029             : /*
    1030             :  * PrintQueryResult: print out (or store or execute) query result as required
    1031             :  *
    1032             :  * last is true if this is the last result of a command string.
    1033             :  * opt and printQueryFout are defined as for PrintQueryTuples.
    1034             :  * printStatusFout is where to send command status; NULL means pset.queryFout.
    1035             :  *
    1036             :  * Returns true if the query executed successfully, false otherwise.
    1037             :  */
    1038             : static bool
    1039      299384 : PrintQueryResult(PGresult *result, bool last,
    1040             :                  const printQueryOpt *opt, FILE *printQueryFout,
    1041             :                  FILE *printStatusFout)
    1042             : {
    1043             :     bool        success;
    1044             : 
    1045      299384 :     if (!result)
    1046           0 :         return false;
    1047             : 
    1048      299384 :     switch (PQresultStatus(result))
    1049             :     {
    1050      132702 :         case PGRES_TUPLES_OK:
    1051             :             /* store or execute or print the data ... */
    1052      132702 :             if (last && pset.gset_prefix)
    1053         744 :                 success = StoreQueryTuple(result);
    1054      131958 :             else if (last && pset.gexec_flag)
    1055          46 :                 success = ExecQueryTuples(result);
    1056      131912 :             else if (last && pset.crosstab_flag)
    1057         132 :                 success = PrintResultInCrosstab(result);
    1058      131780 :             else if (last || pset.show_all_results)
    1059      131766 :                 success = PrintQueryTuples(result, opt, printQueryFout);
    1060             :             else
    1061          14 :                 success = true;
    1062             : 
    1063             :             /*
    1064             :              * If it's INSERT/UPDATE/DELETE/MERGE RETURNING, also print
    1065             :              * status.
    1066             :              */
    1067      132702 :             if (last || pset.show_all_results)
    1068      132688 :                 PrintQueryStatus(result, printStatusFout);
    1069             : 
    1070      132702 :             break;
    1071             : 
    1072      166548 :         case PGRES_COMMAND_OK:
    1073      166548 :             if (last || pset.show_all_results)
    1074      166548 :                 PrintQueryStatus(result, printStatusFout);
    1075      166548 :             success = true;
    1076      166548 :             break;
    1077             : 
    1078         134 :         case PGRES_EMPTY_QUERY:
    1079         134 :             success = true;
    1080         134 :             break;
    1081             : 
    1082           0 :         case PGRES_COPY_OUT:
    1083             :         case PGRES_COPY_IN:
    1084             :             /* nothing to do here: already processed */
    1085           0 :             success = true;
    1086           0 :             break;
    1087             : 
    1088           0 :         case PGRES_PIPELINE_ABORTED:
    1089             :         case PGRES_BAD_RESPONSE:
    1090             :         case PGRES_NONFATAL_ERROR:
    1091             :         case PGRES_FATAL_ERROR:
    1092           0 :             success = false;
    1093           0 :             break;
    1094             : 
    1095           0 :         default:
    1096           0 :             success = false;
    1097           0 :             pg_log_error("unexpected PQresultStatus: %d",
    1098             :                          PQresultStatus(result));
    1099           0 :             break;
    1100             :     }
    1101             : 
    1102      299384 :     return success;
    1103             : }
    1104             : 
    1105             : /*
    1106             :  * SendQuery: send the query string to the backend
    1107             :  * (and print out result)
    1108             :  *
    1109             :  * Note: This is the "front door" way to send a query. That is, use it to
    1110             :  * send queries actually entered by the user. These queries will be subject to
    1111             :  * single step mode.
    1112             :  * To send "back door" queries (generated by slash commands, etc.) in a
    1113             :  * controlled way, use PSQLexec().
    1114             :  *
    1115             :  * Returns true if the query executed successfully, false otherwise.
    1116             :  */
    1117             : bool
    1118      340946 : SendQuery(const char *query)
    1119             : {
    1120      340946 :     bool        timing = pset.timing;
    1121             :     PGTransactionStatusType transaction_status;
    1122      340946 :     double      elapsed_msec = 0;
    1123      340946 :     bool        OK = false;
    1124             :     int         i;
    1125      340946 :     bool        on_error_rollback_savepoint = false;
    1126      340946 :     bool        svpt_gone = false;
    1127             : 
    1128      340946 :     if (!pset.db)
    1129             :     {
    1130           0 :         pg_log_error("You are currently not connected to a database.");
    1131           0 :         goto sendquery_cleanup;
    1132             :     }
    1133             : 
    1134      340946 :     if (pset.singlestep)
    1135             :     {
    1136             :         char        buf[3];
    1137             : 
    1138           0 :         fflush(stderr);
    1139           0 :         printf(_("/**(Single step mode: verify command)******************************************/\n"
    1140             :                  "%s\n"
    1141             :                  "/**(press return to proceed or enter x and return to cancel)*******************/\n"),
    1142             :                query);
    1143           0 :         fflush(stdout);
    1144           0 :         if (fgets(buf, sizeof(buf), stdin) != NULL)
    1145           0 :             if (buf[0] == 'x')
    1146           0 :                 goto sendquery_cleanup;
    1147           0 :         if (cancel_pressed)
    1148           0 :             goto sendquery_cleanup;
    1149             :     }
    1150      340946 :     else if (pset.echo == PSQL_ECHO_QUERIES)
    1151             :     {
    1152          80 :         puts(query);
    1153          80 :         fflush(stdout);
    1154             :     }
    1155             : 
    1156      340946 :     if (pset.logfile)
    1157             :     {
    1158           0 :         fprintf(pset.logfile,
    1159           0 :                 _("/******** QUERY *********/\n"
    1160             :                   "%s\n"
    1161             :                   "/************************/\n\n"), query);
    1162           0 :         fflush(pset.logfile);
    1163             :     }
    1164             : 
    1165      340946 :     SetCancelConn(pset.db);
    1166             : 
    1167      340946 :     transaction_status = PQtransactionStatus(pset.db);
    1168             : 
    1169      340946 :     if (transaction_status == PQTRANS_IDLE &&
    1170      311250 :         !pset.autocommit &&
    1171          84 :         !command_no_begin(query))
    1172             :     {
    1173             :         PGresult   *result;
    1174             : 
    1175          72 :         result = PQexec(pset.db, "BEGIN");
    1176          72 :         if (PQresultStatus(result) != PGRES_COMMAND_OK)
    1177             :         {
    1178           0 :             pg_log_info("%s", PQerrorMessage(pset.db));
    1179           0 :             ClearOrSaveResult(result);
    1180           0 :             goto sendquery_cleanup;
    1181             :         }
    1182          72 :         ClearOrSaveResult(result);
    1183          72 :         transaction_status = PQtransactionStatus(pset.db);
    1184             :     }
    1185             : 
    1186      340946 :     if (transaction_status == PQTRANS_INTRANS &&
    1187       27466 :         pset.on_error_rollback != PSQL_ERROR_ROLLBACK_OFF &&
    1188         156 :         (pset.cur_cmd_interactive ||
    1189         156 :          pset.on_error_rollback == PSQL_ERROR_ROLLBACK_ON))
    1190             :     {
    1191             :         PGresult   *result;
    1192             : 
    1193         156 :         result = PQexec(pset.db, "SAVEPOINT pg_psql_temporary_savepoint");
    1194         156 :         if (PQresultStatus(result) != PGRES_COMMAND_OK)
    1195             :         {
    1196           0 :             pg_log_info("%s", PQerrorMessage(pset.db));
    1197           0 :             ClearOrSaveResult(result);
    1198           0 :             goto sendquery_cleanup;
    1199             :         }
    1200         156 :         ClearOrSaveResult(result);
    1201         156 :         on_error_rollback_savepoint = true;
    1202             :     }
    1203             : 
    1204      340946 :     if (pset.gdesc_flag)
    1205             :     {
    1206             :         /* Describe query's result columns, without executing it */
    1207          86 :         OK = DescribeQuery(query, &elapsed_msec);
    1208             :     }
    1209             :     else
    1210             :     {
    1211             :         /* Default fetch-and-print mode */
    1212      340860 :         OK = (ExecQueryAndProcessResults(query, &elapsed_msec, &svpt_gone, false, 0, NULL, NULL) > 0);
    1213             :     }
    1214             : 
    1215      340928 :     if (!OK && pset.echo == PSQL_ECHO_ERRORS)
    1216           6 :         pg_log_info("STATEMENT:  %s", query);
    1217             : 
    1218             :     /* If we made a temporary savepoint, possibly release/rollback */
    1219      340928 :     if (on_error_rollback_savepoint)
    1220             :     {
    1221         156 :         const char *svptcmd = NULL;
    1222             : 
    1223         156 :         transaction_status = PQtransactionStatus(pset.db);
    1224             : 
    1225         156 :         switch (transaction_status)
    1226             :         {
    1227          42 :             case PQTRANS_INERROR:
    1228             :                 /* We always rollback on an error */
    1229          42 :                 svptcmd = "ROLLBACK TO pg_psql_temporary_savepoint";
    1230          42 :                 break;
    1231             : 
    1232          42 :             case PQTRANS_IDLE:
    1233             :                 /* If they are no longer in a transaction, then do nothing */
    1234          42 :                 break;
    1235             : 
    1236          72 :             case PQTRANS_INTRANS:
    1237             : 
    1238             :                 /*
    1239             :                  * Release our savepoint, but do nothing if they are messing
    1240             :                  * with savepoints themselves
    1241             :                  */
    1242          72 :                 if (!svpt_gone)
    1243          66 :                     svptcmd = "RELEASE pg_psql_temporary_savepoint";
    1244          72 :                 break;
    1245             : 
    1246           0 :             case PQTRANS_ACTIVE:
    1247             :             case PQTRANS_UNKNOWN:
    1248             :             default:
    1249           0 :                 OK = false;
    1250             :                 /* PQTRANS_UNKNOWN is expected given a broken connection. */
    1251           0 :                 if (transaction_status != PQTRANS_UNKNOWN || ConnectionUp())
    1252           0 :                     pg_log_error("unexpected transaction status (%d)",
    1253             :                                  transaction_status);
    1254           0 :                 break;
    1255             :         }
    1256             : 
    1257         156 :         if (svptcmd)
    1258             :         {
    1259             :             PGresult   *svptres;
    1260             : 
    1261         108 :             svptres = PQexec(pset.db, svptcmd);
    1262         108 :             if (PQresultStatus(svptres) != PGRES_COMMAND_OK)
    1263             :             {
    1264           0 :                 pg_log_info("%s", PQerrorMessage(pset.db));
    1265           0 :                 ClearOrSaveResult(svptres);
    1266           0 :                 OK = false;
    1267             : 
    1268           0 :                 goto sendquery_cleanup;
    1269             :             }
    1270         108 :             PQclear(svptres);
    1271             :         }
    1272             :     }
    1273             : 
    1274             :     /* Possible microtiming output */
    1275      340928 :     if (timing)
    1276           4 :         PrintTiming(elapsed_msec);
    1277             : 
    1278             :     /* check for events that may occur during query execution */
    1279             : 
    1280      340956 :     if (pset.encoding != PQclientEncoding(pset.db) &&
    1281          28 :         PQclientEncoding(pset.db) >= 0)
    1282             :     {
    1283             :         /* track effects of SET CLIENT_ENCODING */
    1284          28 :         pset.encoding = PQclientEncoding(pset.db);
    1285          28 :         pset.popt.topt.encoding = pset.encoding;
    1286          28 :         SetVariable(pset.vars, "ENCODING",
    1287             :                     pg_encoding_to_char(pset.encoding));
    1288             :     }
    1289             : 
    1290      340928 :     PrintNotifications();
    1291             : 
    1292             :     /* perform cleanup that should occur after any attempted query */
    1293             : 
    1294      340928 : sendquery_cleanup:
    1295             : 
    1296             :     /* global cancellation reset */
    1297      340928 :     ResetCancelConn();
    1298             : 
    1299             :     /* reset \g's output-to-filename trigger */
    1300      340928 :     if (pset.gfname)
    1301             :     {
    1302          32 :         free(pset.gfname);
    1303          32 :         pset.gfname = NULL;
    1304             :     }
    1305             : 
    1306             :     /* restore print settings if \g changed them */
    1307      340928 :     if (pset.gsavepopt)
    1308             :     {
    1309          42 :         restorePsetInfo(&pset.popt, pset.gsavepopt);
    1310          42 :         pset.gsavepopt = NULL;
    1311             :     }
    1312             : 
    1313             :     /* clean up after extended protocol queries */
    1314      340928 :     clean_extended_state();
    1315             : 
    1316             :     /* reset \gset trigger */
    1317      340928 :     if (pset.gset_prefix)
    1318             :     {
    1319         744 :         free(pset.gset_prefix);
    1320         744 :         pset.gset_prefix = NULL;
    1321             :     }
    1322             : 
    1323             :     /* reset \gdesc trigger */
    1324      340928 :     pset.gdesc_flag = false;
    1325             : 
    1326             :     /* reset \gexec trigger */
    1327      340928 :     pset.gexec_flag = false;
    1328             : 
    1329             :     /* reset \crosstabview trigger */
    1330      340928 :     pset.crosstab_flag = false;
    1331     1704640 :     for (i = 0; i < lengthof(pset.ctv_args); i++)
    1332             :     {
    1333     1363712 :         pg_free(pset.ctv_args[i]);
    1334     1363712 :         pset.ctv_args[i] = NULL;
    1335             :     }
    1336             : 
    1337      340928 :     return OK;
    1338             : }
    1339             : 
    1340             : 
    1341             : /*
    1342             :  * DescribeQuery: describe the result columns of a query, without executing it
    1343             :  *
    1344             :  * Returns true if the operation executed successfully, false otherwise.
    1345             :  *
    1346             :  * If pset.timing is on, total query time (exclusive of result-printing) is
    1347             :  * stored into *elapsed_msec.
    1348             :  */
    1349             : static bool
    1350          86 : DescribeQuery(const char *query, double *elapsed_msec)
    1351             : {
    1352          86 :     bool        timing = pset.timing;
    1353             :     PGresult   *result;
    1354             :     bool        OK;
    1355             :     instr_time  before,
    1356             :                 after;
    1357             : 
    1358          86 :     *elapsed_msec = 0;
    1359             : 
    1360          86 :     if (timing)
    1361           0 :         INSTR_TIME_SET_CURRENT(before);
    1362             :     else
    1363          86 :         INSTR_TIME_SET_ZERO(before);
    1364             : 
    1365             :     /*
    1366             :      * To parse the query but not execute it, we prepare it, using the unnamed
    1367             :      * prepared statement.  This is invisible to psql users, since there's no
    1368             :      * way to access the unnamed prepared statement from psql user space. The
    1369             :      * next Parse or Query protocol message would overwrite the statement
    1370             :      * anyway.  (So there's no great need to clear it when done, which is a
    1371             :      * good thing because libpq provides no easy way to do that.)
    1372             :      */
    1373          86 :     result = PQprepare(pset.db, "", query, 0, NULL);
    1374          86 :     if (PQresultStatus(result) != PGRES_COMMAND_OK)
    1375             :     {
    1376          32 :         pg_log_info("%s", PQerrorMessage(pset.db));
    1377          32 :         SetResultVariables(result, false);
    1378          32 :         ClearOrSaveResult(result);
    1379          32 :         return false;
    1380             :     }
    1381          54 :     PQclear(result);
    1382             : 
    1383          54 :     result = PQdescribePrepared(pset.db, "");
    1384         108 :     OK = AcceptResult(result, true) &&
    1385          54 :         (PQresultStatus(result) == PGRES_COMMAND_OK);
    1386          54 :     if (OK && result)
    1387             :     {
    1388          54 :         if (PQnfields(result) > 0)
    1389             :         {
    1390             :             PQExpBufferData buf;
    1391             :             int         i;
    1392             : 
    1393          36 :             initPQExpBuffer(&buf);
    1394             : 
    1395          36 :             printfPQExpBuffer(&buf,
    1396             :                               "SELECT name AS \"%s\", pg_catalog.format_type(tp, tpm) AS \"%s\"\n"
    1397             :                               "FROM (VALUES ",
    1398             :                               gettext_noop("Column"),
    1399             :                               gettext_noop("Type"));
    1400             : 
    1401         162 :             for (i = 0; i < PQnfields(result); i++)
    1402             :             {
    1403             :                 const char *name;
    1404             :                 char       *escname;
    1405             : 
    1406         126 :                 if (i > 0)
    1407          90 :                     appendPQExpBufferStr(&buf, ",");
    1408             : 
    1409         126 :                 name = PQfname(result, i);
    1410         126 :                 escname = PQescapeLiteral(pset.db, name, strlen(name));
    1411             : 
    1412         126 :                 if (escname == NULL)
    1413             :                 {
    1414           0 :                     pg_log_info("%s", PQerrorMessage(pset.db));
    1415           0 :                     PQclear(result);
    1416           0 :                     termPQExpBuffer(&buf);
    1417           0 :                     return false;
    1418             :                 }
    1419             : 
    1420         126 :                 appendPQExpBuffer(&buf, "(%s, '%u'::pg_catalog.oid, %d)",
    1421             :                                   escname,
    1422             :                                   PQftype(result, i),
    1423             :                                   PQfmod(result, i));
    1424             : 
    1425         126 :                 PQfreemem(escname);
    1426             :             }
    1427             : 
    1428          36 :             appendPQExpBufferStr(&buf, ") s(name, tp, tpm)");
    1429          36 :             PQclear(result);
    1430             : 
    1431          36 :             result = PQexec(pset.db, buf.data);
    1432          36 :             OK = AcceptResult(result, true);
    1433             : 
    1434          36 :             if (timing)
    1435             :             {
    1436           0 :                 INSTR_TIME_SET_CURRENT(after);
    1437           0 :                 INSTR_TIME_SUBTRACT(after, before);
    1438           0 :                 *elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
    1439             :             }
    1440             : 
    1441          36 :             if (OK && result)
    1442          36 :                 OK = PrintQueryResult(result, true, NULL, NULL, NULL);
    1443             : 
    1444          36 :             termPQExpBuffer(&buf);
    1445             :         }
    1446             :         else
    1447          18 :             fprintf(pset.queryFout,
    1448          18 :                     _("The command has no result, or the result has no columns.\n"));
    1449             :     }
    1450             : 
    1451          54 :     SetResultVariables(result, OK);
    1452          54 :     ClearOrSaveResult(result);
    1453             : 
    1454          54 :     return OK;
    1455             : }
    1456             : 
    1457             : /*
    1458             :  * Read and discard all results in an aborted pipeline.
    1459             :  *
    1460             :  * If a synchronisation point is found, we can stop discarding results as
    1461             :  * the pipeline will switch back to a clean state.  If no synchronisation
    1462             :  * point is available, we need to stop when ther are no more pending
    1463             :  * results, otherwise, calling PQgetResult() would block.
    1464             :  */
    1465             : static PGresult *
    1466         378 : discardAbortedPipelineResults(void)
    1467             : {
    1468             :     for (;;)
    1469         270 :     {
    1470         378 :         PGresult   *res = PQgetResult(pset.db);
    1471         378 :         ExecStatusType result_status = PQresultStatus(res);
    1472             : 
    1473         378 :         if (result_status == PGRES_PIPELINE_SYNC)
    1474             :         {
    1475             :             /*
    1476             :              * Found a synchronisation point.  The sync counter is decremented
    1477             :              * by the caller.
    1478             :              */
    1479          66 :             return res;
    1480             :         }
    1481         312 :         else if (res == NULL)
    1482             :         {
    1483             :             /* A query was processed, decrement the counters */
    1484             :             Assert(pset.available_results > 0);
    1485             :             Assert(pset.requested_results > 0);
    1486         210 :             pset.available_results--;
    1487         210 :             pset.requested_results--;
    1488             :         }
    1489             : 
    1490         312 :         if (pset.requested_results == 0)
    1491             :         {
    1492             :             /* We have read all the requested results, leave */
    1493          42 :             return res;
    1494             :         }
    1495             : 
    1496         270 :         if (pset.available_results == 0 && pset.piped_syncs == 0)
    1497             :         {
    1498             :             /*
    1499             :              * There are no more results to get and there is no
    1500             :              * synchronisation point to stop at.  This will leave the pipeline
    1501             :              * in an aborted state.
    1502             :              */
    1503           0 :             return res;
    1504             :         }
    1505             : 
    1506             :         /*
    1507             :          * An aborted pipeline will have either NULL results or results in an
    1508             :          * PGRES_PIPELINE_ABORTED status.
    1509             :          */
    1510             :         Assert(res == NULL || result_status == PGRES_PIPELINE_ABORTED);
    1511         270 :         PQclear(res);
    1512             :     }
    1513             : }
    1514             : 
    1515             : /*
    1516             :  * ExecQueryAndProcessResults: utility function for use by SendQuery()
    1517             :  * and PSQLexecWatch().
    1518             :  *
    1519             :  * Sends query and cycles through PGresult objects.
    1520             :  *
    1521             :  * If our command string contained a COPY FROM STDIN or COPY TO STDOUT, the
    1522             :  * PGresult associated with these commands must be processed by providing an
    1523             :  * input or output stream.  In that event, we'll marshal data for the COPY.
    1524             :  *
    1525             :  * For other commands, the results are processed normally, depending on their
    1526             :  * status and the status of a pipeline.
    1527             :  *
    1528             :  * When invoked from \watch, is_watch is true and min_rows is the value
    1529             :  * of that option, or 0 if it wasn't set.
    1530             :  *
    1531             :  * Returns 1 on complete success, 0 on interrupt and -1 or errors.  Possible
    1532             :  * failure modes include purely client-side problems; check the transaction
    1533             :  * status for the server-side opinion.
    1534             :  *
    1535             :  * Note that on a combined query, failure does not mean that nothing was
    1536             :  * committed.
    1537             :  */
    1538             : static int
    1539      340902 : ExecQueryAndProcessResults(const char *query,
    1540             :                            double *elapsed_msec, bool *svpt_gone_p,
    1541             :                            bool is_watch, int min_rows,
    1542             :                            const printQueryOpt *opt, FILE *printQueryFout)
    1543             : {
    1544      340902 :     bool        timing = pset.timing;
    1545      340902 :     bool        success = false;
    1546      340902 :     bool        return_early = false;
    1547      340902 :     bool        end_pipeline = false;
    1548             :     instr_time  before,
    1549             :                 after;
    1550             :     PGresult   *result;
    1551      340902 :     FILE       *gfile_fout = NULL;
    1552      340902 :     bool        gfile_is_pipe = false;
    1553             : 
    1554      340902 :     if (timing)
    1555           4 :         INSTR_TIME_SET_CURRENT(before);
    1556             :     else
    1557      340898 :         INSTR_TIME_SET_ZERO(before);
    1558             : 
    1559      340902 :     switch (pset.send_mode)
    1560             :     {
    1561          36 :         case PSQL_SEND_EXTENDED_CLOSE:
    1562          36 :             success = PQsendClosePrepared(pset.db, pset.stmtName);
    1563          36 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1564          18 :                 pset.piped_commands++;
    1565          36 :             break;
    1566          96 :         case PSQL_SEND_EXTENDED_PARSE:
    1567          96 :             success = PQsendPrepare(pset.db, pset.stmtName, query, 0, NULL);
    1568          96 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1569          66 :                 pset.piped_commands++;
    1570          96 :             break;
    1571         646 :         case PSQL_SEND_EXTENDED_QUERY_PARAMS:
    1572             :             Assert(pset.stmtName == NULL);
    1573        1292 :             success = PQsendQueryParams(pset.db, query,
    1574             :                                         pset.bind_nparams, NULL,
    1575         646 :                                         (const char *const *) pset.bind_params,
    1576             :                                         NULL, NULL, 0);
    1577         646 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1578         588 :                 pset.piped_commands++;
    1579         646 :             break;
    1580         114 :         case PSQL_SEND_EXTENDED_QUERY_PREPARED:
    1581             :             Assert(pset.stmtName != NULL);
    1582         228 :             success = PQsendQueryPrepared(pset.db, pset.stmtName,
    1583             :                                           pset.bind_nparams,
    1584         114 :                                           (const char *const *) pset.bind_params,
    1585             :                                           NULL, NULL, 0);
    1586         114 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1587          48 :                 pset.piped_commands++;
    1588         114 :             break;
    1589         354 :         case PSQL_SEND_START_PIPELINE_MODE:
    1590         354 :             success = PQenterPipelineMode(pset.db);
    1591         354 :             break;
    1592         354 :         case PSQL_SEND_END_PIPELINE_MODE:
    1593         354 :             success = PQpipelineSync(pset.db);
    1594         354 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1595             :             {
    1596             :                 /*
    1597             :                  * End of the pipeline, all queued commands need to be
    1598             :                  * processed.
    1599             :                  */
    1600         348 :                 end_pipeline = true;
    1601         348 :                 pset.piped_syncs++;
    1602             : 
    1603             :                 /*
    1604             :                  * The server will send a ReadyForQuery after a Sync is
    1605             :                  * processed, flushing all the results back to the client.
    1606             :                  */
    1607         348 :                 pset.available_results += pset.piped_commands;
    1608         348 :                 pset.piped_commands = 0;
    1609             : 
    1610             :                 /* We want to read all results */
    1611         348 :                 pset.requested_results = pset.available_results + pset.piped_syncs;
    1612             :             }
    1613         354 :             break;
    1614         126 :         case PSQL_SEND_PIPELINE_SYNC:
    1615         126 :             success = PQsendPipelineSync(pset.db);
    1616         126 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1617             :             {
    1618         126 :                 pset.piped_syncs++;
    1619             : 
    1620             :                 /*
    1621             :                  * The server will send a ReadyForQuery after a Sync is
    1622             :                  * processed, flushing all the results back to the client.
    1623             :                  */
    1624         126 :                 pset.available_results += pset.piped_commands;
    1625         126 :                 pset.piped_commands = 0;
    1626             :             }
    1627         126 :             break;
    1628          18 :         case PSQL_SEND_FLUSH:
    1629          18 :             success = PQflush(pset.db);
    1630          18 :             break;
    1631          78 :         case PSQL_SEND_FLUSH_REQUEST:
    1632          78 :             success = PQsendFlushRequest(pset.db);
    1633          78 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1634             :             {
    1635             :                 /*
    1636             :                  * With the flush request, all commands in the pipeline are
    1637             :                  * pushed and the server will flush the results back to the
    1638             :                  * client, making them available.
    1639             :                  */
    1640          78 :                 pset.available_results += pset.piped_commands;
    1641          78 :                 pset.piped_commands = 0;
    1642             :             }
    1643          78 :             break;
    1644         192 :         case PSQL_SEND_GET_RESULTS:
    1645         192 :             if (pset.available_results == 0 && pset.piped_syncs == 0)
    1646             :             {
    1647             :                 /*
    1648             :                  * If no sync or flush request were sent, PQgetResult() would
    1649             :                  * block as there are no results available.  Forbid any
    1650             :                  * attempt to get pending results should we try to reach this
    1651             :                  * state.
    1652             :                  */
    1653          24 :                 pg_log_info("No pending results to get");
    1654          24 :                 success = false;
    1655          24 :                 pset.requested_results = 0;
    1656             :             }
    1657             :             else
    1658             :             {
    1659         168 :                 success = true;
    1660             : 
    1661             :                 /*
    1662             :                  * Cap requested_results to the maximum number of known
    1663             :                  * results.
    1664             :                  */
    1665         168 :                 if (pset.requested_results == 0 ||
    1666          54 :                     pset.requested_results > (pset.available_results + pset.piped_syncs))
    1667         114 :                     pset.requested_results = pset.available_results + pset.piped_syncs;
    1668             :             }
    1669         192 :             break;
    1670      338888 :         case PSQL_SEND_QUERY:
    1671      338888 :             if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1672             :             {
    1673         162 :                 success = PQsendQueryParams(pset.db, query,
    1674             :                                             0, NULL, NULL, NULL, NULL, 0);
    1675         162 :                 if (success)
    1676         162 :                     pset.piped_commands++;
    1677             :             }
    1678             :             else
    1679      338726 :                 success = PQsendQuery(pset.db, query);
    1680      338888 :             break;
    1681             :     }
    1682             : 
    1683      340902 :     if (!success)
    1684             :     {
    1685          48 :         const char *error = PQerrorMessage(pset.db);
    1686             : 
    1687          48 :         if (strlen(error))
    1688           6 :             pg_log_info("%s", error);
    1689             : 
    1690          48 :         CheckConnection();
    1691             : 
    1692          48 :         SetPipelineVariables();
    1693             : 
    1694          48 :         return -1;
    1695             :     }
    1696             : 
    1697      681192 :     if (pset.requested_results == 0 && !end_pipeline &&
    1698      340338 :         PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1699             :     {
    1700             :         /*
    1701             :          * We are in a pipeline and have not reached the pipeline end, or
    1702             :          * there was no request to read pipeline results.  Update the psql
    1703             :          * variables tracking the pipeline activity and exit.
    1704             :          */
    1705        1440 :         SetPipelineVariables();
    1706        1440 :         return 1;
    1707             :     }
    1708             : 
    1709             :     /*
    1710             :      * Fetch the result in chunks if FETCH_COUNT is set, except when:
    1711             :      *
    1712             :      * * SHOW_ALL_RESULTS is false, since that requires us to complete the
    1713             :      * query before we can tell if its results should be displayed.
    1714             :      *
    1715             :      * * We're doing \crosstab, which likewise needs to see all the rows at
    1716             :      * once.
    1717             :      *
    1718             :      * * We're doing \gexec: we must complete the data fetch to make the
    1719             :      * connection free for issuing the resulting commands.
    1720             :      *
    1721             :      * * We're doing \gset: only one result row is allowed anyway.
    1722             :      *
    1723             :      * * We're doing \watch: users probably don't want us to force use of the
    1724             :      * pager for that, plus chunking could break the min_rows check.
    1725             :      */
    1726      339414 :     if (pset.fetch_count > 0 && pset.show_all_results &&
    1727         134 :         !pset.crosstab_flag && !pset.gexec_flag &&
    1728         128 :         !pset.gset_prefix && !is_watch)
    1729             :     {
    1730         104 :         if (!PQsetChunkedRowsMode(pset.db, pset.fetch_count))
    1731           6 :             pg_log_warning("fetching results in chunked mode failed");
    1732             :     }
    1733             : 
    1734             :     /*
    1735             :      * If SIGINT is sent while the query is processing, the interrupt will be
    1736             :      * consumed.  The user's intention, though, is to cancel the entire watch
    1737             :      * process, so detect a sent cancellation request and exit in this case.
    1738             :      */
    1739      339414 :     if (is_watch && cancel_pressed)
    1740             :     {
    1741           0 :         ClearOrSaveAllResults();
    1742           0 :         return 0;
    1743             :     }
    1744             : 
    1745             :     /* first result */
    1746      339414 :     result = PQgetResult(pset.db);
    1747      339414 :     if (min_rows > 0 && PQntuples(result) < min_rows)
    1748             :     {
    1749           2 :         return_early = true;
    1750             :     }
    1751             : 
    1752      681174 :     while (result != NULL)
    1753             :     {
    1754             :         ExecStatusType result_status;
    1755      341780 :         bool        is_chunked_result = false;
    1756      341780 :         PGresult   *next_result = NULL;
    1757             :         bool        last;
    1758             : 
    1759      341780 :         if (!AcceptResult(result, false))
    1760             :         {
    1761             :             /*
    1762             :              * Some error occurred, either a server-side failure or a failure
    1763             :              * to submit the command string.  Record that.
    1764             :              */
    1765       41144 :             const char *error = PQresultErrorMessage(result);
    1766             : 
    1767       41144 :             if (strlen(error))
    1768       41112 :                 pg_log_info("%s", error);
    1769             : 
    1770       41144 :             CheckConnection();
    1771       41124 :             if (!is_watch)
    1772       41122 :                 SetResultVariables(result, false);
    1773             : 
    1774             :             /* keep the result status before clearing it */
    1775       41124 :             result_status = PQresultStatus(result);
    1776       41124 :             ClearOrSaveResult(result);
    1777       41124 :             success = false;
    1778             : 
    1779       41124 :             if (result_status == PGRES_PIPELINE_ABORTED)
    1780          30 :                 pg_log_info("Pipeline aborted, command did not run");
    1781             : 
    1782             :             /*
    1783             :              * switch to next result
    1784             :              */
    1785       41124 :             if (result_status == PGRES_COPY_BOTH ||
    1786       41122 :                 result_status == PGRES_COPY_OUT ||
    1787             :                 result_status == PGRES_COPY_IN)
    1788             :             {
    1789             :                 /*
    1790             :                  * For some obscure reason PQgetResult does *not* return a
    1791             :                  * NULL in copy cases despite the result having been cleared,
    1792             :                  * but keeps returning an "empty" result that we have to
    1793             :                  * ignore manually.
    1794             :                  */
    1795           2 :                 result = NULL;
    1796             :             }
    1797       41122 :             else if ((end_pipeline || pset.requested_results > 0)
    1798         108 :                      && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1799             :             {
    1800             :                 /*
    1801             :                  * Error within a pipeline.  All commands are aborted until
    1802             :                  * the next synchronisation point.  We need to consume all the
    1803             :                  * results until this synchronisation point, or stop when
    1804             :                  * there are no more result to discard.
    1805             :                  *
    1806             :                  * Checking the pipeline status is necessary for the case
    1807             :                  * where the connection was reset.  The new connection is not
    1808             :                  * in any kind of pipeline state and thus has no result to
    1809             :                  * discard.
    1810             :                  */
    1811         108 :                 result = discardAbortedPipelineResults();
    1812             :             }
    1813             :             else
    1814       41014 :                 result = PQgetResult(pset.db);
    1815             : 
    1816             :             /*
    1817             :              * Get current timing measure in case an error occurs
    1818             :              */
    1819       41124 :             if (timing)
    1820             :             {
    1821           2 :                 INSTR_TIME_SET_CURRENT(after);
    1822           2 :                 INSTR_TIME_SUBTRACT(after, before);
    1823           2 :                 *elapsed_msec = INSTR_TIME_GET_MILLISEC(after);
    1824             :             }
    1825             : 
    1826       41124 :             continue;
    1827             :         }
    1828      300636 :         else if (svpt_gone_p && !*svpt_gone_p)
    1829             :         {
    1830             :             /*
    1831             :              * Check if the user ran any command that would destroy our
    1832             :              * internal savepoint: If the user did COMMIT AND CHAIN, RELEASE
    1833             :              * or ROLLBACK, our savepoint is gone. If they issued a SAVEPOINT,
    1834             :              * releasing ours would remove theirs.
    1835             :              */
    1836      300506 :             const char *cmd = PQcmdStatus(result);
    1837             : 
    1838      899868 :             *svpt_gone_p = (strcmp(cmd, "COMMIT") == 0 ||
    1839      298856 :                             strcmp(cmd, "SAVEPOINT") == 0 ||
    1840      896922 :                             strcmp(cmd, "RELEASE") == 0 ||
    1841      297560 :                             strcmp(cmd, "ROLLBACK") == 0);
    1842             :         }
    1843             : 
    1844      300636 :         result_status = PQresultStatus(result);
    1845             : 
    1846             :         /* must handle COPY before changing the current result */
    1847             :         Assert(result_status != PGRES_COPY_BOTH);
    1848      300636 :         if (result_status == PGRES_COPY_IN ||
    1849             :             result_status == PGRES_COPY_OUT)
    1850             :         {
    1851        1520 :             FILE       *copy_stream = NULL;
    1852             : 
    1853             :             /*
    1854             :              * For COPY OUT, direct the output to the default place (probably
    1855             :              * a pager pipe) for \watch, or to pset.copyStream for \copy,
    1856             :              * otherwise to pset.gfname if that's set, otherwise to
    1857             :              * pset.queryFout.
    1858             :              */
    1859        1520 :             if (result_status == PGRES_COPY_OUT)
    1860             :             {
    1861         570 :                 if (is_watch)
    1862             :                 {
    1863             :                     /* invoked by \watch */
    1864           0 :                     copy_stream = printQueryFout ? printQueryFout : pset.queryFout;
    1865             :                 }
    1866         570 :                 else if (pset.copyStream)
    1867             :                 {
    1868             :                     /* invoked by \copy */
    1869          54 :                     copy_stream = pset.copyStream;
    1870             :                 }
    1871         516 :                 else if (pset.gfname)
    1872             :                 {
    1873             :                     /* COPY followed by \g filename or \g |program */
    1874          26 :                     success &= SetupGOutput(&gfile_fout, &gfile_is_pipe);
    1875          26 :                     if (gfile_fout)
    1876          26 :                         copy_stream = gfile_fout;
    1877             :                 }
    1878             :                 else
    1879             :                 {
    1880             :                     /* fall back to the generic query output stream */
    1881         490 :                     copy_stream = pset.queryFout;
    1882             :                 }
    1883             :             }
    1884             : 
    1885             :             /*
    1886             :              * Even if the output stream could not be opened, we call
    1887             :              * HandleCopyResult() with a NULL output stream to collect and
    1888             :              * discard the COPY data.
    1889             :              */
    1890        1520 :             success &= HandleCopyResult(&result, copy_stream);
    1891             :         }
    1892             : 
    1893             :         /* If we have a chunked result, collect and print all chunks */
    1894      300636 :         if (result_status == PGRES_TUPLES_CHUNK)
    1895             :         {
    1896          66 :             FILE       *tuples_fout = printQueryFout ? printQueryFout : pset.queryFout;
    1897          66 :             printQueryOpt my_popt = opt ? *opt : pset.popt;
    1898          66 :             int64       total_tuples = 0;
    1899          66 :             bool        is_pager = false;
    1900          66 :             int         flush_error = 0;
    1901             : 
    1902             :             /* initialize print options for partial table output */
    1903          66 :             my_popt.topt.start_table = true;
    1904          66 :             my_popt.topt.stop_table = false;
    1905          66 :             my_popt.topt.prior_records = 0;
    1906             : 
    1907             :             /* open \g file if needed */
    1908          66 :             success &= SetupGOutput(&gfile_fout, &gfile_is_pipe);
    1909          66 :             if (gfile_fout)
    1910           0 :                 tuples_fout = gfile_fout;
    1911             : 
    1912             :             /* force use of pager for any chunked resultset going to stdout */
    1913          66 :             if (success && tuples_fout == stdout)
    1914             :             {
    1915          66 :                 tuples_fout = PageOutput(INT_MAX, &(my_popt.topt));
    1916          66 :                 is_pager = true;
    1917             :             }
    1918             : 
    1919             :             do
    1920             :             {
    1921             :                 /*
    1922             :                  * Display the current chunk of results, unless the output
    1923             :                  * stream stopped working or we got canceled.  We skip use of
    1924             :                  * PrintQueryResult and go directly to printQuery, so that we
    1925             :                  * can pass the correct is_pager value and because we don't
    1926             :                  * want PrintQueryStatus to happen yet.  Above, we rejected
    1927             :                  * use of chunking for all cases in which PrintQueryResult
    1928             :                  * would send the result to someplace other than printQuery.
    1929             :                  */
    1930          90 :                 if (success && !flush_error && !cancel_pressed)
    1931             :                 {
    1932          90 :                     printQuery(result, &my_popt, tuples_fout, is_pager, pset.logfile);
    1933          90 :                     flush_error = fflush(tuples_fout);
    1934             :                 }
    1935             : 
    1936             :                 /* after the first result set, disallow header decoration */
    1937          90 :                 my_popt.topt.start_table = false;
    1938             : 
    1939             :                 /* count tuples before dropping the result */
    1940          90 :                 my_popt.topt.prior_records += PQntuples(result);
    1941          90 :                 total_tuples += PQntuples(result);
    1942             : 
    1943          90 :                 ClearOrSaveResult(result);
    1944             : 
    1945             :                 /* get the next result, loop if it's PGRES_TUPLES_CHUNK */
    1946          90 :                 result = PQgetResult(pset.db);
    1947          90 :             } while (PQresultStatus(result) == PGRES_TUPLES_CHUNK);
    1948             : 
    1949             :             /* We expect an empty PGRES_TUPLES_OK, else there's a problem */
    1950          66 :             if (PQresultStatus(result) == PGRES_TUPLES_OK)
    1951             :             {
    1952             :                 char        buf[32];
    1953             : 
    1954             :                 Assert(PQntuples(result) == 0);
    1955             : 
    1956             :                 /* Display the footer using the empty result */
    1957          60 :                 if (success && !flush_error && !cancel_pressed)
    1958             :                 {
    1959          60 :                     my_popt.topt.stop_table = true;
    1960          60 :                     printQuery(result, &my_popt, tuples_fout, is_pager, pset.logfile);
    1961          60 :                     fflush(tuples_fout);
    1962             :                 }
    1963             : 
    1964          60 :                 if (is_pager)
    1965          60 :                     ClosePager(tuples_fout);
    1966             : 
    1967             :                 /*
    1968             :                  * It's possible the data is from a RETURNING clause, in which
    1969             :                  * case we need to print query status.
    1970             :                  */
    1971          60 :                 PrintQueryStatus(result, printQueryFout);
    1972             : 
    1973             :                 /*
    1974             :                  * We must do a fake SetResultVariables(), since we don't have
    1975             :                  * a PGresult corresponding to the whole query.
    1976             :                  */
    1977          60 :                 SetVariable(pset.vars, "ERROR", "false");
    1978          60 :                 SetVariable(pset.vars, "SQLSTATE", "00000");
    1979          60 :                 snprintf(buf, sizeof(buf), INT64_FORMAT, total_tuples);
    1980          60 :                 SetVariable(pset.vars, "ROW_COUNT", buf);
    1981             :                 /* Prevent SetResultVariables call below */
    1982          60 :                 is_chunked_result = true;
    1983             : 
    1984             :                 /* Clear the empty result so it isn't printed below */
    1985          60 :                 ClearOrSaveResult(result);
    1986          60 :                 result = NULL;
    1987             :             }
    1988             :             else
    1989             :             {
    1990             :                 /* Probably an error report, so close the pager and print it */
    1991           6 :                 if (is_pager)
    1992           6 :                     ClosePager(tuples_fout);
    1993             : 
    1994           6 :                 success &= AcceptResult(result, true);
    1995             :                 /* SetResultVariables and ClearOrSaveResult happen below */
    1996             :             }
    1997             :         }
    1998             : 
    1999      300636 :         if (result_status == PGRES_PIPELINE_SYNC)
    2000             :         {
    2001             :             Assert(pset.piped_syncs > 0);
    2002             : 
    2003             :             /*
    2004             :              * Sync response, decrease the sync and requested_results
    2005             :              * counters.
    2006             :              */
    2007         474 :             pset.piped_syncs--;
    2008         474 :             pset.requested_results--;
    2009             : 
    2010             :             /*
    2011             :              * After a synchronisation point, reset success state to print
    2012             :              * possible successful results that will be processed after this.
    2013             :              */
    2014         474 :             success = true;
    2015             : 
    2016             :             /*
    2017             :              * If all syncs were processed and pipeline end was requested,
    2018             :              * exit pipeline mode.
    2019             :              */
    2020         474 :             if (end_pipeline && pset.piped_syncs == 0)
    2021         348 :                 success &= PQexitPipelineMode(pset.db);
    2022             :         }
    2023      300162 :         else if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF &&
    2024             :                  result_status != PGRES_PIPELINE_SYNC)
    2025             :         {
    2026             :             /*
    2027             :              * In a pipeline with a non-sync response?  Decrease the result
    2028             :              * counters.
    2029             :              */
    2030         672 :             pset.available_results--;
    2031         672 :             pset.requested_results--;
    2032             :         }
    2033             : 
    2034             :         /*
    2035             :          * Check PQgetResult() again.  In the typical case of a single-command
    2036             :          * string, it will return NULL.  Otherwise, we'll have other results
    2037             :          * to process.  We need to do that to check whether this is the last.
    2038             :          */
    2039      300636 :         if (PQpipelineStatus(pset.db) == PQ_PIPELINE_OFF)
    2040      299838 :             next_result = PQgetResult(pset.db);
    2041             :         else
    2042             :         {
    2043             :             /*
    2044             :              * In pipeline mode, a NULL result indicates the end of the
    2045             :              * current query being processed.  Call PQgetResult() once to
    2046             :              * consume this state.
    2047             :              */
    2048         798 :             if (result_status != PGRES_PIPELINE_SYNC)
    2049             :             {
    2050         672 :                 next_result = PQgetResult(pset.db);
    2051             :                 Assert(next_result == NULL);
    2052             :             }
    2053             : 
    2054             :             /* Now, we can get the next result in the pipeline. */
    2055         798 :             if (pset.requested_results > 0)
    2056         672 :                 next_result = PQgetResult(pset.db);
    2057             :         }
    2058             : 
    2059      300636 :         last = (next_result == NULL);
    2060             : 
    2061             :         /*
    2062             :          * Update current timing measure.
    2063             :          *
    2064             :          * It will include the display of previous results, if any. This
    2065             :          * cannot be helped because the server goes on processing further
    2066             :          * queries anyway while the previous ones are being displayed. The
    2067             :          * parallel execution of the client display hides the server time when
    2068             :          * it is shorter.
    2069             :          *
    2070             :          * With combined queries, timing must be understood as an upper bound
    2071             :          * of the time spent processing them.
    2072             :          */
    2073      300636 :         if (timing)
    2074             :         {
    2075           2 :             INSTR_TIME_SET_CURRENT(after);
    2076           2 :             INSTR_TIME_SUBTRACT(after, before);
    2077           2 :             *elapsed_msec = INSTR_TIME_GET_MILLISEC(after);
    2078             :         }
    2079             : 
    2080             :         /*
    2081             :          * This may or may not print something depending on settings.
    2082             :          *
    2083             :          * A pipeline sync will have a non-NULL result but does not have
    2084             :          * anything to print, thus ignore results in this case.
    2085             :          */
    2086      300636 :         if (result != NULL && result_status != PGRES_PIPELINE_SYNC)
    2087             :         {
    2088             :             /*
    2089             :              * If results need to be printed into the file specified by \g,
    2090             :              * open it, unless we already did.  Note that when pset.gfname is
    2091             :              * set, the passed-in value of printQueryFout is not used for
    2092             :              * tuple output, but it's still used for status output.
    2093             :              */
    2094      299558 :             FILE       *tuples_fout = printQueryFout;
    2095             : 
    2096      299558 :             if (PQresultStatus(result) == PGRES_TUPLES_OK)
    2097      132666 :                 success &= SetupGOutput(&gfile_fout, &gfile_is_pipe);
    2098      299558 :             if (gfile_fout)
    2099          60 :                 tuples_fout = gfile_fout;
    2100      299558 :             if (success)
    2101      299348 :                 success &= PrintQueryResult(result, last, opt,
    2102             :                                             tuples_fout, printQueryFout);
    2103             :         }
    2104             : 
    2105             :         /* set variables from last result, unless dealt with elsewhere */
    2106      300636 :         if (last && !is_watch && !is_chunked_result)
    2107      298248 :             SetResultVariables(result, success);
    2108             : 
    2109      300636 :         ClearOrSaveResult(result);
    2110      300636 :         result = next_result;
    2111             : 
    2112      300636 :         if (cancel_pressed && PQpipelineStatus(pset.db) == PQ_PIPELINE_OFF)
    2113             :         {
    2114             :             /*
    2115             :              * Outside of a pipeline, drop the next result, as well as any
    2116             :              * others not yet read.
    2117             :              *
    2118             :              * Within a pipeline, we can let the outer loop handle this as an
    2119             :              * aborted pipeline, which will discard then all the results.
    2120             :              */
    2121           0 :             ClearOrSaveResult(result);
    2122           0 :             ClearOrSaveAllResults();
    2123           0 :             break;
    2124             :         }
    2125             :     }
    2126             : 
    2127             :     /* close \g file if we opened it */
    2128      339394 :     CloseGOutput(gfile_fout, gfile_is_pipe);
    2129             : 
    2130             :     if (end_pipeline)
    2131             :     {
    2132             :         /* after a pipeline is processed, pipeline piped_syncs should be 0 */
    2133             :         Assert(pset.piped_syncs == 0);
    2134             :         /* all commands have been processed */
    2135             :         Assert(pset.piped_commands == 0);
    2136             :         /* all results were read */
    2137             :         Assert(pset.available_results == 0);
    2138             :     }
    2139             :     Assert(pset.requested_results == 0);
    2140      339394 :     SetPipelineVariables();
    2141             : 
    2142             :     /* may need this to recover from conn loss during COPY */
    2143      339394 :     if (!CheckConnection())
    2144           0 :         return -1;
    2145             : 
    2146      339394 :     if (cancel_pressed || return_early)
    2147           4 :         return 0;
    2148             : 
    2149      339390 :     return success ? 1 : -1;
    2150             : }
    2151             : 
    2152             : 
    2153             : /*
    2154             :  * Advance the given char pointer over white space and SQL comments.
    2155             :  */
    2156             : static const char *
    2157         108 : skip_white_space(const char *query)
    2158             : {
    2159         108 :     int         cnestlevel = 0; /* slash-star comment nest level */
    2160             : 
    2161         132 :     while (*query)
    2162             :     {
    2163         132 :         int         mblen = PQmblenBounded(query, pset.encoding);
    2164             : 
    2165             :         /*
    2166             :          * Note: we assume the encoding is a superset of ASCII, so that for
    2167             :          * example "query[0] == '/'" is meaningful.  However, we do NOT assume
    2168             :          * that the second and subsequent bytes of a multibyte character
    2169             :          * couldn't look like ASCII characters; so it is critical to advance
    2170             :          * by mblen, not 1, whenever we haven't exactly identified the
    2171             :          * character we are skipping over.
    2172             :          */
    2173         132 :         if (isspace((unsigned char) *query))
    2174          24 :             query += mblen;
    2175         108 :         else if (query[0] == '/' && query[1] == '*')
    2176             :         {
    2177           0 :             cnestlevel++;
    2178           0 :             query += 2;
    2179             :         }
    2180         108 :         else if (cnestlevel > 0 && query[0] == '*' && query[1] == '/')
    2181             :         {
    2182           0 :             cnestlevel--;
    2183           0 :             query += 2;
    2184             :         }
    2185         108 :         else if (cnestlevel == 0 && query[0] == '-' && query[1] == '-')
    2186             :         {
    2187           0 :             query += 2;
    2188             : 
    2189             :             /*
    2190             :              * We have to skip to end of line since any slash-star inside the
    2191             :              * -- comment does NOT start a slash-star comment.
    2192             :              */
    2193           0 :             while (*query)
    2194             :             {
    2195           0 :                 if (*query == '\n')
    2196             :                 {
    2197           0 :                     query++;
    2198           0 :                     break;
    2199             :                 }
    2200           0 :                 query += PQmblenBounded(query, pset.encoding);
    2201             :             }
    2202             :         }
    2203         108 :         else if (cnestlevel > 0)
    2204           0 :             query += mblen;
    2205             :         else
    2206         108 :             break;              /* found first token */
    2207             :     }
    2208             : 
    2209         108 :     return query;
    2210             : }
    2211             : 
    2212             : 
    2213             : /*
    2214             :  * Check whether a command is one of those for which we should NOT start
    2215             :  * a new transaction block (ie, send a preceding BEGIN).
    2216             :  *
    2217             :  * These include the transaction control statements themselves, plus
    2218             :  * certain statements that the backend disallows inside transaction blocks.
    2219             :  */
    2220             : static bool
    2221          84 : command_no_begin(const char *query)
    2222             : {
    2223             :     int         wordlen;
    2224             : 
    2225             :     /*
    2226             :      * First we must advance over any whitespace and comments.
    2227             :      */
    2228          84 :     query = skip_white_space(query);
    2229             : 
    2230             :     /*
    2231             :      * Check word length (since "beginx" is not "begin").
    2232             :      */
    2233          84 :     wordlen = 0;
    2234         564 :     while (isalpha((unsigned char) query[wordlen]))
    2235         480 :         wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2236             : 
    2237             :     /*
    2238             :      * Transaction control commands.  These should include every keyword that
    2239             :      * gives rise to a TransactionStmt in the backend grammar, except for the
    2240             :      * savepoint-related commands.
    2241             :      *
    2242             :      * (We assume that START must be START TRANSACTION, since there is
    2243             :      * presently no other "START foo" command.)
    2244             :      */
    2245          84 :     if (wordlen == 5 && pg_strncasecmp(query, "abort", 5) == 0)
    2246           0 :         return true;
    2247          84 :     if (wordlen == 5 && pg_strncasecmp(query, "begin", 5) == 0)
    2248          12 :         return true;
    2249          72 :     if (wordlen == 5 && pg_strncasecmp(query, "start", 5) == 0)
    2250           0 :         return true;
    2251          72 :     if (wordlen == 6 && pg_strncasecmp(query, "commit", 6) == 0)
    2252           0 :         return true;
    2253          72 :     if (wordlen == 3 && pg_strncasecmp(query, "end", 3) == 0)
    2254           0 :         return true;
    2255          72 :     if (wordlen == 8 && pg_strncasecmp(query, "rollback", 8) == 0)
    2256           0 :         return true;
    2257          72 :     if (wordlen == 7 && pg_strncasecmp(query, "prepare", 7) == 0)
    2258             :     {
    2259             :         /* PREPARE TRANSACTION is a TC command, PREPARE foo is not */
    2260           0 :         query += wordlen;
    2261             : 
    2262           0 :         query = skip_white_space(query);
    2263             : 
    2264           0 :         wordlen = 0;
    2265           0 :         while (isalpha((unsigned char) query[wordlen]))
    2266           0 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2267             : 
    2268           0 :         if (wordlen == 11 && pg_strncasecmp(query, "transaction", 11) == 0)
    2269           0 :             return true;
    2270           0 :         return false;
    2271             :     }
    2272             : 
    2273             :     /*
    2274             :      * Commands not allowed within transactions.  The statements checked for
    2275             :      * here should be exactly those that call PreventInTransactionBlock() in
    2276             :      * the backend.
    2277             :      */
    2278          72 :     if (wordlen == 6 && pg_strncasecmp(query, "vacuum", 6) == 0)
    2279           0 :         return true;
    2280          72 :     if (wordlen == 7 && pg_strncasecmp(query, "cluster", 7) == 0)
    2281             :     {
    2282             :         /* CLUSTER with any arguments is allowed in transactions */
    2283           0 :         query += wordlen;
    2284             : 
    2285           0 :         query = skip_white_space(query);
    2286             : 
    2287           0 :         if (isalpha((unsigned char) query[0]))
    2288           0 :             return false;       /* has additional words */
    2289           0 :         return true;            /* it's CLUSTER without arguments */
    2290             :     }
    2291             : 
    2292          72 :     if (wordlen == 6 && pg_strncasecmp(query, "create", 6) == 0)
    2293             :     {
    2294          12 :         query += wordlen;
    2295             : 
    2296          12 :         query = skip_white_space(query);
    2297             : 
    2298          12 :         wordlen = 0;
    2299          72 :         while (isalpha((unsigned char) query[wordlen]))
    2300          60 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2301             : 
    2302          12 :         if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
    2303           0 :             return true;
    2304          12 :         if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
    2305           0 :             return true;
    2306             : 
    2307             :         /* CREATE [UNIQUE] INDEX CONCURRENTLY isn't allowed in xacts */
    2308          12 :         if (wordlen == 6 && pg_strncasecmp(query, "unique", 6) == 0)
    2309             :         {
    2310           0 :             query += wordlen;
    2311             : 
    2312           0 :             query = skip_white_space(query);
    2313             : 
    2314           0 :             wordlen = 0;
    2315           0 :             while (isalpha((unsigned char) query[wordlen]))
    2316           0 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2317             :         }
    2318             : 
    2319          12 :         if (wordlen == 5 && pg_strncasecmp(query, "index", 5) == 0)
    2320             :         {
    2321           0 :             query += wordlen;
    2322             : 
    2323           0 :             query = skip_white_space(query);
    2324             : 
    2325           0 :             wordlen = 0;
    2326           0 :             while (isalpha((unsigned char) query[wordlen]))
    2327           0 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2328             : 
    2329           0 :             if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
    2330           0 :                 return true;
    2331             :         }
    2332             : 
    2333          12 :         return false;
    2334             :     }
    2335             : 
    2336          60 :     if (wordlen == 5 && pg_strncasecmp(query, "alter", 5) == 0)
    2337             :     {
    2338           0 :         query += wordlen;
    2339             : 
    2340           0 :         query = skip_white_space(query);
    2341             : 
    2342           0 :         wordlen = 0;
    2343           0 :         while (isalpha((unsigned char) query[wordlen]))
    2344           0 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2345             : 
    2346             :         /* ALTER SYSTEM isn't allowed in xacts */
    2347           0 :         if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
    2348           0 :             return true;
    2349             : 
    2350           0 :         return false;
    2351             :     }
    2352             : 
    2353             :     /*
    2354             :      * Note: these tests will match DROP SYSTEM and REINDEX TABLESPACE, which
    2355             :      * aren't really valid commands so we don't care much. The other four
    2356             :      * possible matches are correct.
    2357             :      */
    2358          60 :     if ((wordlen == 4 && pg_strncasecmp(query, "drop", 4) == 0) ||
    2359           0 :         (wordlen == 7 && pg_strncasecmp(query, "reindex", 7) == 0))
    2360             :     {
    2361           6 :         query += wordlen;
    2362             : 
    2363           6 :         query = skip_white_space(query);
    2364             : 
    2365           6 :         wordlen = 0;
    2366          36 :         while (isalpha((unsigned char) query[wordlen]))
    2367          30 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2368             : 
    2369           6 :         if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
    2370           0 :             return true;
    2371           6 :         if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
    2372           0 :             return true;
    2373           6 :         if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
    2374           0 :             return true;
    2375          12 :         if (wordlen == 5 && (pg_strncasecmp(query, "index", 5) == 0 ||
    2376           6 :                              pg_strncasecmp(query, "table", 5) == 0))
    2377             :         {
    2378           6 :             query += wordlen;
    2379           6 :             query = skip_white_space(query);
    2380           6 :             wordlen = 0;
    2381          24 :             while (isalpha((unsigned char) query[wordlen]))
    2382          18 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2383             : 
    2384             :             /*
    2385             :              * REINDEX [ TABLE | INDEX ] CONCURRENTLY are not allowed in
    2386             :              * xacts.
    2387             :              */
    2388           6 :             if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
    2389           0 :                 return true;
    2390             :         }
    2391             : 
    2392             :         /* DROP INDEX CONCURRENTLY isn't allowed in xacts */
    2393           6 :         if (wordlen == 5 && pg_strncasecmp(query, "index", 5) == 0)
    2394             :         {
    2395           0 :             query += wordlen;
    2396             : 
    2397           0 :             query = skip_white_space(query);
    2398             : 
    2399           0 :             wordlen = 0;
    2400           0 :             while (isalpha((unsigned char) query[wordlen]))
    2401           0 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2402             : 
    2403           0 :             if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
    2404           0 :                 return true;
    2405             : 
    2406           0 :             return false;
    2407             :         }
    2408             : 
    2409           6 :         return false;
    2410             :     }
    2411             : 
    2412             :     /* DISCARD ALL isn't allowed in xacts, but other variants are allowed. */
    2413          54 :     if (wordlen == 7 && pg_strncasecmp(query, "discard", 7) == 0)
    2414             :     {
    2415           0 :         query += wordlen;
    2416             : 
    2417           0 :         query = skip_white_space(query);
    2418             : 
    2419           0 :         wordlen = 0;
    2420           0 :         while (isalpha((unsigned char) query[wordlen]))
    2421           0 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2422             : 
    2423           0 :         if (wordlen == 3 && pg_strncasecmp(query, "all", 3) == 0)
    2424           0 :             return true;
    2425           0 :         return false;
    2426             :     }
    2427             : 
    2428          54 :     return false;
    2429             : }
    2430             : 
    2431             : 
    2432             : /*
    2433             :  * Test if the current user is a database superuser.
    2434             :  */
    2435             : bool
    2436         116 : is_superuser(void)
    2437             : {
    2438             :     const char *val;
    2439             : 
    2440         116 :     if (!pset.db)
    2441           0 :         return false;
    2442             : 
    2443         116 :     val = PQparameterStatus(pset.db, "is_superuser");
    2444             : 
    2445         116 :     if (val && strcmp(val, "on") == 0)
    2446         116 :         return true;
    2447             : 
    2448           0 :     return false;
    2449             : }
    2450             : 
    2451             : 
    2452             : /*
    2453             :  * Test if the current session uses standard string literals.
    2454             :  */
    2455             : bool
    2456      649738 : standard_strings(void)
    2457             : {
    2458             :     const char *val;
    2459             : 
    2460      649738 :     if (!pset.db)
    2461           0 :         return false;
    2462             : 
    2463      649738 :     val = PQparameterStatus(pset.db, "standard_conforming_strings");
    2464             : 
    2465      649738 :     if (val && strcmp(val, "on") == 0)
    2466      649546 :         return true;
    2467             : 
    2468         192 :     return false;
    2469             : }
    2470             : 
    2471             : 
    2472             : /*
    2473             :  * Return the session user of the current connection.
    2474             :  */
    2475             : const char *
    2476           0 : session_username(void)
    2477             : {
    2478             :     const char *val;
    2479             : 
    2480           0 :     if (!pset.db)
    2481           0 :         return NULL;
    2482             : 
    2483           0 :     val = PQparameterStatus(pset.db, "session_authorization");
    2484           0 :     if (val)
    2485           0 :         return val;
    2486             :     else
    2487           0 :         return PQuser(pset.db);
    2488             : }
    2489             : 
    2490             : 
    2491             : /* expand_tilde
    2492             :  *
    2493             :  * substitute '~' with HOME or '~username' with username's home dir
    2494             :  *
    2495             :  */
    2496             : void
    2497         184 : expand_tilde(char **filename)
    2498             : {
    2499         184 :     if (!filename || !(*filename))
    2500          18 :         return;
    2501             : 
    2502             :     /*
    2503             :      * WIN32 doesn't use tilde expansion for file names. Also, it uses tilde
    2504             :      * for short versions of long file names, though the tilde is usually
    2505             :      * toward the end, not at the beginning.
    2506             :      */
    2507             : #ifndef WIN32
    2508             : 
    2509             :     /* try tilde expansion */
    2510         166 :     if (**filename == '~')
    2511             :     {
    2512             :         char       *fn;
    2513             :         char        oldp,
    2514             :                    *p;
    2515             :         struct passwd *pw;
    2516             :         char        home[MAXPGPATH];
    2517             : 
    2518           0 :         fn = *filename;
    2519           0 :         *home = '\0';
    2520             : 
    2521           0 :         p = fn + 1;
    2522           0 :         while (*p != '/' && *p != '\0')
    2523           0 :             p++;
    2524             : 
    2525           0 :         oldp = *p;
    2526           0 :         *p = '\0';
    2527             : 
    2528           0 :         if (*(fn + 1) == '\0')
    2529           0 :             get_home_path(home);    /* ~ or ~/ only */
    2530           0 :         else if ((pw = getpwnam(fn + 1)) != NULL)
    2531           0 :             strlcpy(home, pw->pw_dir, sizeof(home)); /* ~user */
    2532             : 
    2533           0 :         *p = oldp;
    2534           0 :         if (strlen(home) != 0)
    2535             :         {
    2536             :             char       *newfn;
    2537             : 
    2538           0 :             newfn = psprintf("%s%s", home, p);
    2539           0 :             free(fn);
    2540           0 :             *filename = newfn;
    2541             :         }
    2542             :     }
    2543             : #endif
    2544             : }
    2545             : 
    2546             : /*
    2547             :  * Checks if connection string starts with either of the valid URI prefix
    2548             :  * designators.
    2549             :  *
    2550             :  * Returns the URI prefix length, 0 if the string doesn't contain a URI prefix.
    2551             :  *
    2552             :  * XXX This is a duplicate of the eponymous libpq function.
    2553             :  */
    2554             : static int
    2555          34 : uri_prefix_length(const char *connstr)
    2556             : {
    2557             :     /* The connection URI must start with either of the following designators: */
    2558             :     static const char uri_designator[] = "postgresql://";
    2559             :     static const char short_uri_designator[] = "postgres://";
    2560             : 
    2561          34 :     if (strncmp(connstr, uri_designator,
    2562             :                 sizeof(uri_designator) - 1) == 0)
    2563           0 :         return sizeof(uri_designator) - 1;
    2564             : 
    2565          34 :     if (strncmp(connstr, short_uri_designator,
    2566             :                 sizeof(short_uri_designator) - 1) == 0)
    2567           0 :         return sizeof(short_uri_designator) - 1;
    2568             : 
    2569          34 :     return 0;
    2570             : }
    2571             : 
    2572             : /*
    2573             :  * Reset state related to extended query protocol
    2574             :  *
    2575             :  * Clean up any state related to bind parameters, statement name and
    2576             :  * PSQL_SEND_MODE.  This needs to be called after processing a query or when
    2577             :  * running a new meta-command that uses the extended query protocol, like
    2578             :  * \parse, \bind, etc.
    2579             :  */
    2580             : void
    2581      342018 : clean_extended_state(void)
    2582             : {
    2583             :     int         i;
    2584             : 
    2585      342018 :     switch (pset.send_mode)
    2586             :     {
    2587          36 :         case PSQL_SEND_EXTENDED_CLOSE:  /* \close */
    2588          36 :             free(pset.stmtName);
    2589          36 :             break;
    2590          96 :         case PSQL_SEND_EXTENDED_PARSE:  /* \parse */
    2591          96 :             free(pset.stmtName);
    2592          96 :             break;
    2593         844 :         case PSQL_SEND_EXTENDED_QUERY_PARAMS:   /* \bind */
    2594             :         case PSQL_SEND_EXTENDED_QUERY_PREPARED: /* \bind_named */
    2595        1500 :             for (i = 0; i < pset.bind_nparams; i++)
    2596         656 :                 free(pset.bind_params[i]);
    2597         844 :             free(pset.bind_params);
    2598         844 :             free(pset.stmtName);
    2599         844 :             pset.bind_params = NULL;
    2600         844 :             break;
    2601      341042 :         case PSQL_SEND_QUERY:
    2602             :         case PSQL_SEND_START_PIPELINE_MODE: /* \startpipeline */
    2603             :         case PSQL_SEND_END_PIPELINE_MODE:   /* \endpipeline */
    2604             :         case PSQL_SEND_PIPELINE_SYNC:   /* \syncpipeline */
    2605             :         case PSQL_SEND_FLUSH:   /* \flush */
    2606             :         case PSQL_SEND_GET_RESULTS: /* \getresults */
    2607             :         case PSQL_SEND_FLUSH_REQUEST:   /* \flushrequest */
    2608      341042 :             break;
    2609             :     }
    2610             : 
    2611      342018 :     pset.stmtName = NULL;
    2612      342018 :     pset.send_mode = PSQL_SEND_QUERY;
    2613      342018 : }
    2614             : 
    2615             : /*
    2616             :  * Recognized connection string either starts with a valid URI prefix or
    2617             :  * contains a "=" in it.
    2618             :  *
    2619             :  * Must be consistent with parse_connection_string: anything for which this
    2620             :  * returns true should at least look like it's parseable by that routine.
    2621             :  *
    2622             :  * XXX This is a duplicate of the eponymous libpq function.
    2623             :  */
    2624             : bool
    2625          34 : recognized_connection_string(const char *connstr)
    2626             : {
    2627          34 :     return uri_prefix_length(connstr) != 0 || strchr(connstr, '=') != NULL;
    2628             : }

Generated by: LCOV version 1.14