LCOV - code coverage report
Current view: top level - src/bin/psql - common.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18beta1 Lines: 734 974 75.4 %
Date: 2025-06-07 00:17:11 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       17276 : openQueryOutputFile(const char *fname, FILE **fout, bool *is_pipe)
      57             : {
      58       17276 :     if (!fname || fname[0] == '\0')
      59             :     {
      60       17226 :         *fout = stdout;
      61       17226 :         *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       17276 :     if (*fout == NULL)
      76             :     {
      77           0 :         pg_log_error("%s: %m", fname);
      78           0 :         return false;
      79             :     }
      80             : 
      81       17276 :     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      132148 : 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      132148 :     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      132148 :     return true;
     104             : }
     105             : 
     106             : /*
     107             :  * Close the output stream for \g, if we opened it.
     108             :  */
     109             : static void
     110      341682 : CloseGOutput(FILE *gfile_fout, bool is_pipe)
     111             : {
     112      341682 :     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      341682 : }
     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       17244 : 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       17244 :     if (!openQueryOutputFile(fname, &fout, &is_pipe))
     151           0 :         return false;
     152             : 
     153             :     /* Close old file/pipe */
     154       17244 :     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       17244 :     pset.queryFout = fout;
     163       17244 :     pset.queryFoutPipe = is_pipe;
     164             : 
     165             :     /* Adjust SIGPIPE handling appropriately: ignore signal if is_pipe */
     166       17244 :     set_sigpipe_trap_state(is_pipe);
     167       17244 :     restore_sigpipe_trap();
     168             : 
     169       17244 :     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        3890 : psql_get_variable(const char *varname, PsqlScanQuoteType quote,
     189             :                   void *passthrough)
     190             : {
     191        3890 :     char       *result = NULL;
     192             :     const char *value;
     193             : 
     194             :     /* In an inactive \if branch, suppress all variable substitutions */
     195        3890 :     if (passthrough && !conditional_active((ConditionalStack) passthrough))
     196          72 :         return NULL;
     197             : 
     198        3818 :     value = GetVariable(pset.vars, varname);
     199        3818 :     if (!value)
     200         482 :         return NULL;
     201             : 
     202        3336 :     switch (quote)
     203             :     {
     204        2486 :         case PQUOTE_PLAIN:
     205        2486 :             result = pg_strdup(value);
     206        2486 :             break;
     207         850 :         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         850 :                 if (!pset.db)
     217             :                 {
     218           0 :                     pg_log_error("cannot escape without active connection");
     219           0 :                     return NULL;
     220             :                 }
     221             : 
     222         850 :                 if (quote == PQUOTE_SQL_LITERAL)
     223             :                     escaped_value =
     224         824 :                         PQescapeLiteral(pset.db, value, strlen(value));
     225             :                 else
     226             :                     escaped_value =
     227          26 :                         PQescapeIdentifier(pset.db, value, strlen(value));
     228             : 
     229         850 :                 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         850 :                 result = pg_strdup(escaped_value);
     243         850 :                 PQfreemem(escaped_value);
     244         850 :                 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        3336 :     return result;
     272             : }
     273             : 
     274             : 
     275             : /*
     276             :  * for backend Notice messages (INFO, WARNING, etc)
     277             :  */
     278             : void
     279      153998 : NoticeProcessor(void *arg, const char *message)
     280             : {
     281             :     (void) arg;                 /* not used */
     282      153998 :     pg_log_info("%s", message);
     283      153998 : }
     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       17238 : psql_setup_cancel_handler(void)
     326             : {
     327       17238 :     setup_cancel_handler(psql_cancel_callback);
     328       17238 : }
     329             : 
     330             : 
     331             : /* ConnectionUp
     332             :  *
     333             :  * Returns whether our backend connection is still there.
     334             :  */
     335             : static bool
     336      383430 : ConnectionUp(void)
     337             : {
     338      383430 :     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      383430 : CheckConnection(void)
     355             : {
     356             :     bool        OK;
     357             : 
     358      383430 :     OK = ConnectionUp();
     359      383430 :     if (!OK)
     360             :     {
     361          26 :         if (!pset.cur_cmd_interactive)
     362             :         {
     363          26 :             pg_log_error("connection to server was lost");
     364          26 :             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      383404 :     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      386316 : AcceptResult(const PGresult *result, bool show_error)
     417             : {
     418             :     bool        OK;
     419             : 
     420      386316 :     if (!result)
     421           0 :         OK = false;
     422             :     else
     423      386316 :         switch (PQresultStatus(result))
     424             :         {
     425      344616 :             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      344616 :                 OK = true;
     434      344616 :                 break;
     435             : 
     436       41698 :             case PGRES_PIPELINE_ABORTED:
     437             :             case PGRES_BAD_RESPONSE:
     438             :             case PGRES_NONFATAL_ERROR:
     439             :             case PGRES_FATAL_ERROR:
     440       41698 :                 OK = false;
     441       41698 :                 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      386316 :     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      386316 :     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      341760 : SetResultVariables(PGresult *result, bool success)
     477             : {
     478      341760 :     if (success)
     479             :     {
     480      299754 :         const char *ntuples = PQcmdTuples(result);
     481             : 
     482      299754 :         SetVariable(pset.vars, "ERROR", "false");
     483      299754 :         SetVariable(pset.vars, "SQLSTATE", "00000");
     484      299754 :         SetVariable(pset.vars, "ROW_COUNT", *ntuples ? ntuples : "0");
     485             :     }
     486             :     else
     487             :     {
     488       42006 :         const char *code = PQresultErrorField(result, PG_DIAG_SQLSTATE);
     489       42006 :         const char *mesg = PQresultErrorField(result, PG_DIAG_MESSAGE_PRIMARY);
     490             : 
     491       42006 :         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       42006 :         if (code == NULL)
     498         160 :             code = "";
     499       42006 :         SetVariable(pset.vars, "SQLSTATE", code);
     500       42006 :         SetVariable(pset.vars, "ROW_COUNT", "0");
     501       42006 :         SetVariable(pset.vars, "LAST_ERROR_SQLSTATE", code);
     502       42006 :         SetVariable(pset.vars, "LAST_ERROR_MESSAGE", mesg ? mesg : "");
     503             :     }
     504      341760 : }
     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      343204 : SetPipelineVariables(void)
     535             : {
     536             :     char        buf[32];
     537             : 
     538      343204 :     snprintf(buf, sizeof(buf), "%d", pset.piped_syncs);
     539      343204 :     SetVariable(pset.vars, "PIPELINE_SYNC_COUNT", buf);
     540      343204 :     snprintf(buf, sizeof(buf), "%d", pset.piped_commands);
     541      343204 :     SetVariable(pset.vars, "PIPELINE_COMMAND_COUNT", buf);
     542      343204 :     snprintf(buf, sizeof(buf), "%d", pset.available_results);
     543      343204 :     SetVariable(pset.vars, "PIPELINE_RESULT_COUNT", buf);
     544      343204 : }
     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      344550 : ClearOrSaveResult(PGresult *result)
     559             : {
     560      344550 :     if (result)
     561             :     {
     562      343922 :         switch (PQresultStatus(result))
     563             :         {
     564       41860 :             case PGRES_NONFATAL_ERROR:
     565             :             case PGRES_FATAL_ERROR:
     566       41860 :                 PQclear(pset.last_error_result);
     567       41860 :                 pset.last_error_result = result;
     568       41860 :                 break;
     569             : 
     570      302062 :             default:
     571      302062 :                 PQclear(result);
     572      302062 :                 break;
     573             :         }
     574             :     }
     575      344550 : }
     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       42104 : PSQLexec(const char *query)
     656             : {
     657             :     PGresult   *res;
     658             : 
     659       42104 :     if (!pset.db)
     660             :     {
     661           0 :         pg_log_error("You are currently not connected to a database.");
     662           0 :         return NULL;
     663             :     }
     664             : 
     665       42104 :     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       42104 :     SetCancelConn(pset.db);
     685             : 
     686       42104 :     res = PQexec(pset.db, query);
     687             : 
     688       42104 :     ResetCancelConn();
     689             : 
     690       42104 :     if (!AcceptResult(res, true))
     691             :     {
     692           0 :         ClearOrSaveResult(res);
     693           0 :         res = NULL;
     694             :     }
     695             : 
     696       42104 :     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          38 : PSQLexecWatch(const char *query, const printQueryOpt *opt, FILE *printQueryFout, int min_rows)
     711             : {
     712          38 :     bool        timing = pset.timing;
     713          38 :     double      elapsed_msec = 0;
     714             :     int         res;
     715             : 
     716          38 :     if (!pset.db)
     717             :     {
     718           0 :         pg_log_error("You are currently not connected to a database.");
     719           0 :         return 0;
     720             :     }
     721             : 
     722          38 :     SetCancelConn(pset.db);
     723             : 
     724          38 :     res = ExecQueryAndProcessResults(query, &elapsed_msec, NULL, true, min_rows, opt, printQueryFout);
     725             : 
     726          36 :     ResetCancelConn();
     727             : 
     728             :     /* Possible microtiming output */
     729          36 :     if (timing)
     730           0 :         PrintTiming(elapsed_msec);
     731             : 
     732          36 :     return res;
     733             : }
     734             : 
     735             : 
     736             : /*
     737             :  * PrintNotifications: check for asynchronous notifications, and print them out
     738             :  */
     739             : static void
     740      343254 : PrintNotifications(void)
     741             : {
     742             :     PGnotify   *notify;
     743             : 
     744      343254 :     PQconsumeInput(pset.db);
     745      343258 :     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      343254 : }
     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      131146 : PrintQueryTuples(const PGresult *result, const printQueryOpt *opt,
     774             :                  FILE *printQueryFout)
     775             : {
     776      131146 :     bool        ok = true;
     777      131146 :     FILE       *fout = printQueryFout ? printQueryFout : pset.queryFout;
     778             : 
     779      131146 :     printQuery(result, opt ? opt : &pset.popt, fout, false, pset.logfile);
     780      131146 :     fflush(fout);
     781      131146 :     if (ferror(fout))
     782             :     {
     783           0 :         pg_log_error("could not print result table: %m");
     784           0 :         ok = false;
     785             :     }
     786             : 
     787      131146 :     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         754 : StoreQueryTuple(const PGresult *result)
     798             : {
     799         754 :     bool        success = true;
     800             : 
     801         754 :     if (PQntuples(result) < 1)
     802             :     {
     803          18 :         pg_log_error("no rows returned for \\gset");
     804          18 :         success = false;
     805             :     }
     806         736 :     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        1622 :         for (i = 0; i < PQnfields(result); i++)
     816             :         {
     817         904 :             char       *colname = PQfname(result, i);
     818             :             char       *varname;
     819             :             char       *value;
     820             : 
     821             :             /* concatenate prefix and column name */
     822         904 :             varname = psprintf("%s%s", pset.gset_prefix, colname);
     823             : 
     824         904 :             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         898 :             if (!PQgetisnull(result, 0, i))
     832         886 :                 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         898 :             if (!SetVariable(pset.vars, varname, value))
     840             :             {
     841           6 :                 free(varname);
     842           6 :                 success = false;
     843           6 :                 break;
     844             :             }
     845             : 
     846         892 :             free(varname);
     847             :         }
     848             :     }
     849             : 
     850         754 :     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        1532 : HandleCopyResult(PGresult **resultp, FILE *copystream)
     938             : {
     939             :     bool        success;
     940             :     PGresult   *copy_result;
     941        1532 :     ExecStatusType result_status = PQresultStatus(*resultp);
     942             : 
     943             :     Assert(result_status == PGRES_COPY_OUT ||
     944             :            result_status == PGRES_COPY_IN);
     945             : 
     946        1532 :     SetCancelConn(pset.db);
     947             : 
     948        1532 :     if (result_status == PGRES_COPY_OUT)
     949             :     {
     950         576 :         success = handleCopyOut(pset.db,
     951             :                                 copystream,
     952             :                                 &copy_result)
     953         576 :             && (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         576 :         if (copystream == pset.queryFout)
     961             :         {
     962         550 :             PQclear(copy_result);
     963         550 :             copy_result = NULL;
     964             :         }
     965             :     }
     966             :     else
     967             :     {
     968             :         /* COPY IN */
     969             :         /* Ignore the copystream argument passed to the function */
     970         956 :         copystream = pset.copyStream ? pset.copyStream : pset.cur_cmd_source;
     971         956 :         success = handleCopyIn(pset.db,
     972             :                                copystream,
     973         956 :                                PQbinaryTuples(*resultp),
     974             :                                &copy_result);
     975             :     }
     976        1532 :     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        1532 :     PQclear(*resultp);
     983        1532 :     *resultp = copy_result;
     984             : 
     985        1532 :     return success;
     986             : }
     987             : 
     988             : /*
     989             :  * PrintQueryStatus: report command status as required
     990             :  */
     991             : static void
     992      300602 : PrintQueryStatus(PGresult *result, FILE *printQueryFout)
     993             : {
     994             :     char        buf[16];
     995      300602 :     const char *cmdstatus = PQcmdStatus(result);
     996      300602 :     FILE       *fout = printQueryFout ? printQueryFout : pset.queryFout;
     997             : 
     998             :     /* Do nothing if it's a TUPLES_OK result that isn't from RETURNING */
     999      300602 :     if (PQresultStatus(result) == PGRES_TUPLES_OK)
    1000             :     {
    1001      132138 :         if (!(strncmp(cmdstatus, "INSERT", 6) == 0 ||
    1002      131672 :               strncmp(cmdstatus, "UPDATE", 6) == 0 ||
    1003      131148 :               strncmp(cmdstatus, "DELETE", 6) == 0 ||
    1004      130934 :               strncmp(cmdstatus, "MERGE", 5) == 0))
    1005      130790 :             return;
    1006             :     }
    1007             : 
    1008      169812 :     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      169812 :     if (pset.logfile)
    1022           0 :         fprintf(pset.logfile, "%s\n", cmdstatus);
    1023             : 
    1024      169812 :     snprintf(buf, sizeof(buf), "%u", (unsigned int) PQoidValue(result));
    1025      169812 :     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      301154 : PrintQueryResult(PGresult *result, bool last,
    1040             :                  const printQueryOpt *opt, FILE *printQueryFout,
    1041             :                  FILE *printStatusFout)
    1042             : {
    1043             :     bool        success;
    1044             : 
    1045      301154 :     if (!result)
    1046           0 :         return false;
    1047             : 
    1048      301154 :     switch (PQresultStatus(result))
    1049             :     {
    1050      132092 :         case PGRES_TUPLES_OK:
    1051             :             /* store or execute or print the data ... */
    1052      132092 :             if (last && pset.gset_prefix)
    1053         754 :                 success = StoreQueryTuple(result);
    1054      131338 :             else if (last && pset.gexec_flag)
    1055          46 :                 success = ExecQueryTuples(result);
    1056      131292 :             else if (last && pset.crosstab_flag)
    1057         132 :                 success = PrintResultInCrosstab(result);
    1058      131160 :             else if (last || pset.show_all_results)
    1059      131146 :                 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      132092 :             if (last || pset.show_all_results)
    1068      132078 :                 PrintQueryStatus(result, printStatusFout);
    1069             : 
    1070      132092 :             break;
    1071             : 
    1072      168464 :         case PGRES_COMMAND_OK:
    1073      168464 :             if (last || pset.show_all_results)
    1074      168464 :                 PrintQueryStatus(result, printStatusFout);
    1075      168464 :             success = true;
    1076      168464 :             break;
    1077             : 
    1078         598 :         case PGRES_EMPTY_QUERY:
    1079         598 :             success = true;
    1080         598 :             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      301154 :     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      343282 : SendQuery(const char *query)
    1119             : {
    1120      343282 :     bool        timing = pset.timing;
    1121             :     PGTransactionStatusType transaction_status;
    1122      343282 :     double      elapsed_msec = 0;
    1123      343282 :     bool        OK = false;
    1124             :     int         i;
    1125      343282 :     bool        on_error_rollback_savepoint = false;
    1126      343282 :     bool        svpt_gone = false;
    1127             : 
    1128      343282 :     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      343282 :     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      343282 :     else if (pset.echo == PSQL_ECHO_QUERIES)
    1151             :     {
    1152          80 :         puts(query);
    1153          80 :         fflush(stdout);
    1154             :     }
    1155             : 
    1156      343282 :     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      343282 :     SetCancelConn(pset.db);
    1166             : 
    1167      343282 :     transaction_status = PQtransactionStatus(pset.db);
    1168             : 
    1169      343282 :     if (transaction_status == PQTRANS_IDLE &&
    1170      312956 :         !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      343282 :     if (transaction_status == PQTRANS_INTRANS &&
    1187       28040 :         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      343282 :     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      343196 :         OK = (ExecQueryAndProcessResults(query, &elapsed_msec, &svpt_gone, false, 0, NULL, NULL) > 0);
    1213             :     }
    1214             : 
    1215      343254 :     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      343254 :     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      343254 :     if (timing)
    1276           4 :         PrintTiming(elapsed_msec);
    1277             : 
    1278             :     /* check for events that may occur during query execution */
    1279             : 
    1280      343282 :     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      343254 :     PrintNotifications();
    1291             : 
    1292             :     /* perform cleanup that should occur after any attempted query */
    1293             : 
    1294      343254 : sendquery_cleanup:
    1295             : 
    1296             :     /* global cancellation reset */
    1297      343254 :     ResetCancelConn();
    1298             : 
    1299             :     /* reset \g's output-to-filename trigger */
    1300      343254 :     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      343254 :     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      343254 :     clean_extended_state();
    1315             : 
    1316             :     /* reset \gset trigger */
    1317      343254 :     if (pset.gset_prefix)
    1318             :     {
    1319         754 :         free(pset.gset_prefix);
    1320         754 :         pset.gset_prefix = NULL;
    1321             :     }
    1322             : 
    1323             :     /* reset \gdesc trigger */
    1324      343254 :     pset.gdesc_flag = false;
    1325             : 
    1326             :     /* reset \gexec trigger */
    1327      343254 :     pset.gexec_flag = false;
    1328             : 
    1329             :     /* reset \crosstabview trigger */
    1330      343254 :     pset.crosstab_flag = false;
    1331     1716270 :     for (i = 0; i < lengthof(pset.ctv_args); i++)
    1332             :     {
    1333     1373016 :         pg_free(pset.ctv_args[i]);
    1334     1373016 :         pset.ctv_args[i] = NULL;
    1335             :     }
    1336             : 
    1337      343254 :     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 :                     appendPQExpBufferChar(&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 there are no more pending
    1463             :  * results, otherwise, calling PQgetResult() would block.
    1464             :  */
    1465             : static PGresult *
    1466         120 : discardAbortedPipelineResults(void)
    1467             : {
    1468             :     for (;;)
    1469         276 :     {
    1470         396 :         PGresult   *res = PQgetResult(pset.db);
    1471         396 :         ExecStatusType result_status = PQresultStatus(res);
    1472             : 
    1473         396 :         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         330 :         else if (res != NULL && result_status == PGRES_FATAL_ERROR)
    1482             :         {
    1483             :             /*
    1484             :              * Found a FATAL error sent by the backend, and we cannot recover
    1485             :              * from this state.  Instead, return the last result and let the
    1486             :              * outer loop handle it.
    1487             :              */
    1488             :             PGresult   *fatal_res PG_USED_FOR_ASSERTS_ONLY;
    1489             : 
    1490             :             /*
    1491             :              * Fetch result to consume the end of the current query being
    1492             :              * processed.
    1493             :              */
    1494          12 :             fatal_res = PQgetResult(pset.db);
    1495             :             Assert(fatal_res == NULL);
    1496          12 :             return res;
    1497             :         }
    1498         318 :         else if (res == NULL)
    1499             :         {
    1500             :             /* A query was processed, decrement the counters */
    1501             :             Assert(pset.available_results > 0);
    1502             :             Assert(pset.requested_results > 0);
    1503         216 :             pset.available_results--;
    1504         216 :             pset.requested_results--;
    1505             :         }
    1506             : 
    1507         318 :         if (pset.requested_results == 0)
    1508             :         {
    1509             :             /* We have read all the requested results, leave */
    1510          42 :             return res;
    1511             :         }
    1512             : 
    1513         276 :         if (pset.available_results == 0 && pset.piped_syncs == 0)
    1514             :         {
    1515             :             /*
    1516             :              * There are no more results to get and there is no
    1517             :              * synchronisation point to stop at.  This will leave the pipeline
    1518             :              * in an aborted state.
    1519             :              */
    1520           0 :             return res;
    1521             :         }
    1522             : 
    1523             :         /*
    1524             :          * An aborted pipeline will have either NULL results or results in an
    1525             :          * PGRES_PIPELINE_ABORTED status.
    1526             :          */
    1527             :         Assert(res == NULL || result_status == PGRES_PIPELINE_ABORTED);
    1528         276 :         PQclear(res);
    1529             :     }
    1530             : }
    1531             : 
    1532             : /*
    1533             :  * ExecQueryAndProcessResults: utility function for use by SendQuery()
    1534             :  * and PSQLexecWatch().
    1535             :  *
    1536             :  * Sends query and cycles through PGresult objects.
    1537             :  *
    1538             :  * If our command string contained a COPY FROM STDIN or COPY TO STDOUT, the
    1539             :  * PGresult associated with these commands must be processed by providing an
    1540             :  * input or output stream.  In that event, we'll marshal data for the COPY.
    1541             :  *
    1542             :  * For other commands, the results are processed normally, depending on their
    1543             :  * status and the status of a pipeline.
    1544             :  *
    1545             :  * When invoked from \watch, is_watch is true and min_rows is the value
    1546             :  * of that option, or 0 if it wasn't set.
    1547             :  *
    1548             :  * Returns 1 on complete success, 0 on interrupt and -1 or errors.  Possible
    1549             :  * failure modes include purely client-side problems; check the transaction
    1550             :  * status for the server-side opinion.
    1551             :  *
    1552             :  * Note that on a combined query, failure does not mean that nothing was
    1553             :  * committed.
    1554             :  */
    1555             : static int
    1556      343234 : ExecQueryAndProcessResults(const char *query,
    1557             :                            double *elapsed_msec, bool *svpt_gone_p,
    1558             :                            bool is_watch, int min_rows,
    1559             :                            const printQueryOpt *opt, FILE *printQueryFout)
    1560             : {
    1561      343234 :     bool        timing = pset.timing;
    1562      343234 :     bool        success = false;
    1563      343234 :     bool        return_early = false;
    1564      343234 :     bool        end_pipeline = false;
    1565             :     instr_time  before,
    1566             :                 after;
    1567             :     PGresult   *result;
    1568      343234 :     FILE       *gfile_fout = NULL;
    1569      343234 :     bool        gfile_is_pipe = false;
    1570             : 
    1571      343234 :     if (timing)
    1572           4 :         INSTR_TIME_SET_CURRENT(before);
    1573             :     else
    1574      343230 :         INSTR_TIME_SET_ZERO(before);
    1575             : 
    1576      343234 :     switch (pset.send_mode)
    1577             :     {
    1578          36 :         case PSQL_SEND_EXTENDED_CLOSE:
    1579          36 :             success = PQsendClosePrepared(pset.db, pset.stmtName);
    1580          36 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1581          18 :                 pset.piped_commands++;
    1582          36 :             break;
    1583          96 :         case PSQL_SEND_EXTENDED_PARSE:
    1584          96 :             success = PQsendPrepare(pset.db, pset.stmtName, query, 0, NULL);
    1585          96 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1586          66 :                 pset.piped_commands++;
    1587          96 :             break;
    1588         668 :         case PSQL_SEND_EXTENDED_QUERY_PARAMS:
    1589             :             Assert(pset.stmtName == NULL);
    1590        1336 :             success = PQsendQueryParams(pset.db, query,
    1591             :                                         pset.bind_nparams, NULL,
    1592         668 :                                         (const char *const *) pset.bind_params,
    1593             :                                         NULL, NULL, 0);
    1594         668 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1595         592 :                 pset.piped_commands++;
    1596         668 :             break;
    1597         114 :         case PSQL_SEND_EXTENDED_QUERY_PREPARED:
    1598             :             Assert(pset.stmtName != NULL);
    1599         228 :             success = PQsendQueryPrepared(pset.db, pset.stmtName,
    1600             :                                           pset.bind_nparams,
    1601         114 :                                           (const char *const *) pset.bind_params,
    1602             :                                           NULL, NULL, 0);
    1603         114 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1604          48 :                 pset.piped_commands++;
    1605         114 :             break;
    1606         364 :         case PSQL_SEND_START_PIPELINE_MODE:
    1607         364 :             success = PQenterPipelineMode(pset.db);
    1608         364 :             break;
    1609         360 :         case PSQL_SEND_END_PIPELINE_MODE:
    1610         360 :             success = PQpipelineSync(pset.db);
    1611         360 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1612             :             {
    1613             :                 /*
    1614             :                  * End of the pipeline, all queued commands need to be
    1615             :                  * processed.
    1616             :                  */
    1617         354 :                 end_pipeline = true;
    1618         354 :                 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         354 :                 pset.available_results += pset.piped_commands;
    1625         354 :                 pset.piped_commands = 0;
    1626             : 
    1627             :                 /* We want to read all results */
    1628         354 :                 pset.requested_results = pset.available_results + pset.piped_syncs;
    1629             :             }
    1630         360 :             break;
    1631         134 :         case PSQL_SEND_PIPELINE_SYNC:
    1632         134 :             success = PQsendPipelineSync(pset.db);
    1633         134 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1634             :             {
    1635         134 :                 pset.piped_syncs++;
    1636             : 
    1637             :                 /*
    1638             :                  * The server will send a ReadyForQuery after a Sync is
    1639             :                  * processed, flushing all the results back to the client.
    1640             :                  */
    1641         134 :                 pset.available_results += pset.piped_commands;
    1642         134 :                 pset.piped_commands = 0;
    1643             :             }
    1644         134 :             break;
    1645          18 :         case PSQL_SEND_FLUSH:
    1646          18 :             success = PQflush(pset.db);
    1647          18 :             break;
    1648          78 :         case PSQL_SEND_FLUSH_REQUEST:
    1649          78 :             success = PQsendFlushRequest(pset.db);
    1650          78 :             if (success && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1651             :             {
    1652             :                 /*
    1653             :                  * With the flush request, all commands in the pipeline are
    1654             :                  * pushed and the server will flush the results back to the
    1655             :                  * client, making them available.
    1656             :                  */
    1657          78 :                 pset.available_results += pset.piped_commands;
    1658          78 :                 pset.piped_commands = 0;
    1659             :             }
    1660          78 :             break;
    1661         196 :         case PSQL_SEND_GET_RESULTS:
    1662         196 :             if (pset.available_results == 0 && pset.piped_syncs == 0)
    1663             :             {
    1664             :                 /*
    1665             :                  * If no sync or flush request were sent, PQgetResult() would
    1666             :                  * block as there are no results available.  Forbid any
    1667             :                  * attempt to get pending results should we try to reach this
    1668             :                  * state.
    1669             :                  */
    1670          24 :                 pg_log_info("No pending results to get");
    1671          24 :                 success = false;
    1672          24 :                 pset.requested_results = 0;
    1673             :             }
    1674             :             else
    1675             :             {
    1676         172 :                 success = true;
    1677             : 
    1678             :                 /*
    1679             :                  * Cap requested_results to the maximum number of known
    1680             :                  * results.
    1681             :                  */
    1682         172 :                 if (pset.requested_results == 0 ||
    1683          54 :                     pset.requested_results > (pset.available_results + pset.piped_syncs))
    1684         118 :                     pset.requested_results = pset.available_results + pset.piped_syncs;
    1685             :             }
    1686         196 :             break;
    1687      341170 :         case PSQL_SEND_QUERY:
    1688      341170 :             if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1689             :             {
    1690         174 :                 success = PQsendQueryParams(pset.db, query,
    1691             :                                             0, NULL, NULL, NULL, NULL, 0);
    1692         174 :                 if (success)
    1693         174 :                     pset.piped_commands++;
    1694             :             }
    1695             :             else
    1696      340996 :                 success = PQsendQuery(pset.db, query);
    1697      341170 :             break;
    1698             :     }
    1699             : 
    1700      343234 :     if (!success)
    1701             :     {
    1702          48 :         const char *error = PQerrorMessage(pset.db);
    1703             : 
    1704          48 :         if (strlen(error))
    1705           6 :             pg_log_info("%s", error);
    1706             : 
    1707          48 :         CheckConnection();
    1708             : 
    1709          48 :         SetPipelineVariables();
    1710             : 
    1711          48 :         return -1;
    1712             :     }
    1713             : 
    1714      685846 :     if (pset.requested_results == 0 && !end_pipeline &&
    1715      342660 :         PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1716             :     {
    1717             :         /*
    1718             :          * We are in a pipeline and have not reached the pipeline end, or
    1719             :          * there was no request to read pipeline results.  Update the psql
    1720             :          * variables tracking the pipeline activity and exit.
    1721             :          */
    1722        1474 :         SetPipelineVariables();
    1723        1474 :         return 1;
    1724             :     }
    1725             : 
    1726             :     /*
    1727             :      * Fetch the result in chunks if FETCH_COUNT is set, except when:
    1728             :      *
    1729             :      * * SHOW_ALL_RESULTS is false, since that requires us to complete the
    1730             :      * query before we can tell if its results should be displayed.
    1731             :      *
    1732             :      * * We're doing \crosstab, which likewise needs to see all the rows at
    1733             :      * once.
    1734             :      *
    1735             :      * * We're doing \gexec: we must complete the data fetch to make the
    1736             :      * connection free for issuing the resulting commands.
    1737             :      *
    1738             :      * * We're doing \gset: only one result row is allowed anyway.
    1739             :      *
    1740             :      * * We're doing \watch: users probably don't want us to force use of the
    1741             :      * pager for that, plus chunking could break the min_rows check.
    1742             :      */
    1743      341712 :     if (pset.fetch_count > 0 && pset.show_all_results &&
    1744         134 :         !pset.crosstab_flag && !pset.gexec_flag &&
    1745         128 :         !pset.gset_prefix && !is_watch)
    1746             :     {
    1747         104 :         if (!PQsetChunkedRowsMode(pset.db, pset.fetch_count))
    1748           6 :             pg_log_warning("fetching results in chunked mode failed");
    1749             :     }
    1750             : 
    1751             :     /*
    1752             :      * If SIGINT is sent while the query is processing, the interrupt will be
    1753             :      * consumed.  The user's intention, though, is to cancel the entire watch
    1754             :      * process, so detect a sent cancellation request and exit in this case.
    1755             :      */
    1756      341712 :     if (is_watch && cancel_pressed)
    1757             :     {
    1758           0 :         ClearOrSaveAllResults();
    1759           0 :         return 0;
    1760             :     }
    1761             : 
    1762             :     /* first result */
    1763      341712 :     result = PQgetResult(pset.db);
    1764      341712 :     if (min_rows > 0 && PQntuples(result) < min_rows)
    1765             :     {
    1766           2 :         return_early = true;
    1767             :     }
    1768             : 
    1769      685798 :     while (result != NULL)
    1770             :     {
    1771             :         ExecStatusType result_status;
    1772      344116 :         bool        is_chunked_result = false;
    1773      344116 :         PGresult   *next_result = NULL;
    1774             :         bool        last;
    1775             : 
    1776      344116 :         if (!AcceptResult(result, false))
    1777       41668 :         {
    1778             :             /*
    1779             :              * Some error occurred, either a server-side failure or a failure
    1780             :              * to submit the command string.  Record that.
    1781             :              */
    1782       41694 :             const char *error = PQresultErrorMessage(result);
    1783             : 
    1784       41694 :             if (strlen(error))
    1785       41656 :                 pg_log_info("%s", error);
    1786             : 
    1787       41694 :             CheckConnection();
    1788       41668 :             if (!is_watch)
    1789       41666 :                 SetResultVariables(result, false);
    1790             : 
    1791             :             /* keep the result status before clearing it */
    1792       41668 :             result_status = PQresultStatus(result);
    1793       41668 :             ClearOrSaveResult(result);
    1794       41668 :             success = false;
    1795             : 
    1796       41668 :             if (result_status == PGRES_PIPELINE_ABORTED)
    1797          36 :                 pg_log_info("Pipeline aborted, command did not run");
    1798             : 
    1799             :             /*
    1800             :              * switch to next result
    1801             :              */
    1802       41668 :             if (result_status == PGRES_COPY_BOTH ||
    1803       41666 :                 result_status == PGRES_COPY_OUT ||
    1804             :                 result_status == PGRES_COPY_IN)
    1805             :             {
    1806             :                 /*
    1807             :                  * For some obscure reason PQgetResult does *not* return a
    1808             :                  * NULL in copy cases despite the result having been cleared,
    1809             :                  * but keeps returning an "empty" result that we have to
    1810             :                  * ignore manually.
    1811             :                  */
    1812           2 :                 result = NULL;
    1813             :             }
    1814       41666 :             else if ((end_pipeline || pset.requested_results > 0)
    1815         120 :                      && PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
    1816             :             {
    1817             :                 /*
    1818             :                  * Error within a pipeline.  All commands are aborted until
    1819             :                  * the next synchronisation point.  We need to consume all the
    1820             :                  * results until this synchronisation point, or stop when
    1821             :                  * there are no more result to discard.
    1822             :                  *
    1823             :                  * Checking the pipeline status is necessary for the case
    1824             :                  * where the connection was reset.  The new connection is not
    1825             :                  * in any kind of pipeline state and thus has no result to
    1826             :                  * discard.
    1827             :                  */
    1828         120 :                 result = discardAbortedPipelineResults();
    1829             :             }
    1830             :             else
    1831       41546 :                 result = PQgetResult(pset.db);
    1832             : 
    1833             :             /*
    1834             :              * Get current timing measure in case an error occurs
    1835             :              */
    1836       41668 :             if (timing)
    1837             :             {
    1838           2 :                 INSTR_TIME_SET_CURRENT(after);
    1839           2 :                 INSTR_TIME_SUBTRACT(after, before);
    1840           2 :                 *elapsed_msec = INSTR_TIME_GET_MILLISEC(after);
    1841             :             }
    1842             : 
    1843       41668 :             continue;
    1844             :         }
    1845      302422 :         else if (svpt_gone_p && !*svpt_gone_p)
    1846             :         {
    1847             :             /*
    1848             :              * Check if the user ran any command that would destroy our
    1849             :              * internal savepoint: If the user did COMMIT AND CHAIN, RELEASE
    1850             :              * or ROLLBACK, our savepoint is gone. If they issued a SAVEPOINT,
    1851             :              * releasing ours would remove theirs.
    1852             :              */
    1853      302296 :             const char *cmd = PQcmdStatus(result);
    1854             : 
    1855      905176 :             *svpt_gone_p = (strcmp(cmd, "COMMIT") == 0 ||
    1856      300584 :                             strcmp(cmd, "SAVEPOINT") == 0 ||
    1857      902144 :                             strcmp(cmd, "RELEASE") == 0 ||
    1858      299264 :                             strcmp(cmd, "ROLLBACK") == 0);
    1859             :         }
    1860             : 
    1861      302422 :         result_status = PQresultStatus(result);
    1862             : 
    1863             :         /* must handle COPY before changing the current result */
    1864             :         Assert(result_status != PGRES_COPY_BOTH);
    1865      302422 :         if (result_status == PGRES_COPY_IN ||
    1866             :             result_status == PGRES_COPY_OUT)
    1867             :         {
    1868        1536 :             FILE       *copy_stream = NULL;
    1869             : 
    1870        1536 :             if (pset.piped_syncs > 1)
    1871             :             {
    1872             :                 /*
    1873             :                  * When reading COPY data, the backend ignores sync messages
    1874             :                  * and will not send a matching ReadyForQuery response.  Even
    1875             :                  * if we adjust piped_syncs and requested_results, it is not
    1876             :                  * possible to salvage this as the sync message would still be
    1877             :                  * in libpq's command queue and we would be stuck in a busy
    1878             :                  * pipeline state.  Thus, we abort the connection to avoid
    1879             :                  * this state.
    1880             :                  */
    1881           4 :                 pg_log_info("\\syncpipeline after COPY is not supported, aborting connection");
    1882           4 :                 exit(EXIT_BADCONN);
    1883             :             }
    1884             : 
    1885             :             /*
    1886             :              * For COPY OUT, direct the output to the default place (probably
    1887             :              * a pager pipe) for \watch, or to pset.copyStream for \copy,
    1888             :              * otherwise to pset.gfname if that's set, otherwise to
    1889             :              * pset.queryFout.
    1890             :              */
    1891        1532 :             if (result_status == PGRES_COPY_OUT)
    1892             :             {
    1893         576 :                 if (is_watch)
    1894             :                 {
    1895             :                     /* invoked by \watch */
    1896           0 :                     copy_stream = printQueryFout ? printQueryFout : pset.queryFout;
    1897             :                 }
    1898         576 :                 else if (pset.copyStream)
    1899             :                 {
    1900             :                     /* invoked by \copy */
    1901          54 :                     copy_stream = pset.copyStream;
    1902             :                 }
    1903         522 :                 else if (pset.gfname)
    1904             :                 {
    1905             :                     /* COPY followed by \g filename or \g |program */
    1906          26 :                     success &= SetupGOutput(&gfile_fout, &gfile_is_pipe);
    1907          26 :                     if (gfile_fout)
    1908          26 :                         copy_stream = gfile_fout;
    1909             :                 }
    1910             :                 else
    1911             :                 {
    1912             :                     /* fall back to the generic query output stream */
    1913         496 :                     copy_stream = pset.queryFout;
    1914             :                 }
    1915             :             }
    1916             : 
    1917             :             /*
    1918             :              * Even if the output stream could not be opened, we call
    1919             :              * HandleCopyResult() with a NULL output stream to collect and
    1920             :              * discard the COPY data.
    1921             :              */
    1922        1532 :             success &= HandleCopyResult(&result, copy_stream);
    1923             :         }
    1924             : 
    1925             :         /* If we have a chunked result, collect and print all chunks */
    1926      302418 :         if (result_status == PGRES_TUPLES_CHUNK)
    1927             :         {
    1928          66 :             FILE       *tuples_fout = printQueryFout ? printQueryFout : pset.queryFout;
    1929          66 :             printQueryOpt my_popt = opt ? *opt : pset.popt;
    1930          66 :             int64       total_tuples = 0;
    1931          66 :             bool        is_pager = false;
    1932          66 :             int         flush_error = 0;
    1933             : 
    1934             :             /* initialize print options for partial table output */
    1935          66 :             my_popt.topt.start_table = true;
    1936          66 :             my_popt.topt.stop_table = false;
    1937          66 :             my_popt.topt.prior_records = 0;
    1938             : 
    1939             :             /* open \g file if needed */
    1940          66 :             success &= SetupGOutput(&gfile_fout, &gfile_is_pipe);
    1941          66 :             if (gfile_fout)
    1942           0 :                 tuples_fout = gfile_fout;
    1943             : 
    1944             :             /* force use of pager for any chunked resultset going to stdout */
    1945          66 :             if (success && tuples_fout == stdout)
    1946             :             {
    1947          66 :                 tuples_fout = PageOutput(INT_MAX, &(my_popt.topt));
    1948          66 :                 is_pager = true;
    1949             :             }
    1950             : 
    1951             :             do
    1952             :             {
    1953             :                 /*
    1954             :                  * Display the current chunk of results, unless the output
    1955             :                  * stream stopped working or we got canceled.  We skip use of
    1956             :                  * PrintQueryResult and go directly to printQuery, so that we
    1957             :                  * can pass the correct is_pager value and because we don't
    1958             :                  * want PrintQueryStatus to happen yet.  Above, we rejected
    1959             :                  * use of chunking for all cases in which PrintQueryResult
    1960             :                  * would send the result to someplace other than printQuery.
    1961             :                  */
    1962          90 :                 if (success && !flush_error && !cancel_pressed)
    1963             :                 {
    1964          90 :                     printQuery(result, &my_popt, tuples_fout, is_pager, pset.logfile);
    1965          90 :                     flush_error = fflush(tuples_fout);
    1966             :                 }
    1967             : 
    1968             :                 /* after the first result set, disallow header decoration */
    1969          90 :                 my_popt.topt.start_table = false;
    1970             : 
    1971             :                 /* count tuples before dropping the result */
    1972          90 :                 my_popt.topt.prior_records += PQntuples(result);
    1973          90 :                 total_tuples += PQntuples(result);
    1974             : 
    1975          90 :                 ClearOrSaveResult(result);
    1976             : 
    1977             :                 /* get the next result, loop if it's PGRES_TUPLES_CHUNK */
    1978          90 :                 result = PQgetResult(pset.db);
    1979          90 :             } while (PQresultStatus(result) == PGRES_TUPLES_CHUNK);
    1980             : 
    1981             :             /* We expect an empty PGRES_TUPLES_OK, else there's a problem */
    1982          66 :             if (PQresultStatus(result) == PGRES_TUPLES_OK)
    1983             :             {
    1984             :                 char        buf[32];
    1985             : 
    1986             :                 Assert(PQntuples(result) == 0);
    1987             : 
    1988             :                 /* Display the footer using the empty result */
    1989          60 :                 if (success && !flush_error && !cancel_pressed)
    1990             :                 {
    1991          60 :                     my_popt.topt.stop_table = true;
    1992          60 :                     printQuery(result, &my_popt, tuples_fout, is_pager, pset.logfile);
    1993          60 :                     fflush(tuples_fout);
    1994             :                 }
    1995             : 
    1996          60 :                 if (is_pager)
    1997          60 :                     ClosePager(tuples_fout);
    1998             : 
    1999             :                 /*
    2000             :                  * It's possible the data is from a RETURNING clause, in which
    2001             :                  * case we need to print query status.
    2002             :                  */
    2003          60 :                 PrintQueryStatus(result, printQueryFout);
    2004             : 
    2005             :                 /*
    2006             :                  * We must do a fake SetResultVariables(), since we don't have
    2007             :                  * a PGresult corresponding to the whole query.
    2008             :                  */
    2009          60 :                 SetVariable(pset.vars, "ERROR", "false");
    2010          60 :                 SetVariable(pset.vars, "SQLSTATE", "00000");
    2011          60 :                 snprintf(buf, sizeof(buf), INT64_FORMAT, total_tuples);
    2012          60 :                 SetVariable(pset.vars, "ROW_COUNT", buf);
    2013             :                 /* Prevent SetResultVariables call below */
    2014          60 :                 is_chunked_result = true;
    2015             : 
    2016             :                 /* Clear the empty result so it isn't printed below */
    2017          60 :                 ClearOrSaveResult(result);
    2018          60 :                 result = NULL;
    2019             :             }
    2020             :             else
    2021             :             {
    2022             :                 /* Probably an error report, so close the pager and print it */
    2023           6 :                 if (is_pager)
    2024           6 :                     ClosePager(tuples_fout);
    2025             : 
    2026           6 :                 success &= AcceptResult(result, true);
    2027             :                 /* SetResultVariables and ClearOrSaveResult happen below */
    2028             :             }
    2029             :         }
    2030             : 
    2031      302418 :         if (result_status == PGRES_PIPELINE_SYNC)
    2032             :         {
    2033             :             Assert(pset.piped_syncs > 0);
    2034             : 
    2035             :             /*
    2036             :              * Sync response, decrease the sync and requested_results
    2037             :              * counters.
    2038             :              */
    2039         474 :             pset.piped_syncs--;
    2040         474 :             pset.requested_results--;
    2041             : 
    2042             :             /*
    2043             :              * After a synchronisation point, reset success state to print
    2044             :              * possible successful results that will be processed after this.
    2045             :              */
    2046         474 :             success = true;
    2047             : 
    2048             :             /*
    2049             :              * If all syncs were processed and pipeline end was requested,
    2050             :              * exit pipeline mode.
    2051             :              */
    2052         474 :             if (end_pipeline && pset.piped_syncs == 0)
    2053         348 :                 success &= PQexitPipelineMode(pset.db);
    2054             :         }
    2055      301944 :         else if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF &&
    2056             :                  result_status != PGRES_PIPELINE_SYNC)
    2057             :         {
    2058             :             /*
    2059             :              * In a pipeline with a non-sync response?  Decrease the result
    2060             :              * counters.
    2061             :              */
    2062         678 :             pset.available_results--;
    2063         678 :             pset.requested_results--;
    2064             :         }
    2065             : 
    2066             :         /*
    2067             :          * Check PQgetResult() again.  In the typical case of a single-command
    2068             :          * string, it will return NULL.  Otherwise, we'll have other results
    2069             :          * to process.  We need to do that to check whether this is the last.
    2070             :          */
    2071      302418 :         if (PQpipelineStatus(pset.db) == PQ_PIPELINE_OFF)
    2072      301614 :             next_result = PQgetResult(pset.db);
    2073             :         else
    2074             :         {
    2075             :             /*
    2076             :              * In pipeline mode, a NULL result indicates the end of the
    2077             :              * current query being processed.  Call PQgetResult() once to
    2078             :              * consume this state.
    2079             :              */
    2080         804 :             if (result_status != PGRES_PIPELINE_SYNC)
    2081             :             {
    2082         678 :                 next_result = PQgetResult(pset.db);
    2083             :                 Assert(next_result == NULL);
    2084             :             }
    2085             : 
    2086             :             /* Now, we can get the next result in the pipeline. */
    2087         804 :             if (pset.requested_results > 0)
    2088         678 :                 next_result = PQgetResult(pset.db);
    2089             :         }
    2090             : 
    2091      302418 :         last = (next_result == NULL);
    2092             : 
    2093             :         /*
    2094             :          * Update current timing measure.
    2095             :          *
    2096             :          * It will include the display of previous results, if any. This
    2097             :          * cannot be helped because the server goes on processing further
    2098             :          * queries anyway while the previous ones are being displayed. The
    2099             :          * parallel execution of the client display hides the server time when
    2100             :          * it is shorter.
    2101             :          *
    2102             :          * With combined queries, timing must be understood as an upper bound
    2103             :          * of the time spent processing them.
    2104             :          */
    2105      302418 :         if (timing)
    2106             :         {
    2107           2 :             INSTR_TIME_SET_CURRENT(after);
    2108           2 :             INSTR_TIME_SUBTRACT(after, before);
    2109           2 :             *elapsed_msec = INSTR_TIME_GET_MILLISEC(after);
    2110             :         }
    2111             : 
    2112             :         /*
    2113             :          * This may or may not print something depending on settings.
    2114             :          *
    2115             :          * A pipeline sync will have a non-NULL result but does not have
    2116             :          * anything to print, thus ignore results in this case.
    2117             :          */
    2118      302418 :         if (result != NULL && result_status != PGRES_PIPELINE_SYNC)
    2119             :         {
    2120             :             /*
    2121             :              * If results need to be printed into the file specified by \g,
    2122             :              * open it, unless we already did.  Note that when pset.gfname is
    2123             :              * set, the passed-in value of printQueryFout is not used for
    2124             :              * tuple output, but it's still used for status output.
    2125             :              */
    2126      301334 :             FILE       *tuples_fout = printQueryFout;
    2127             : 
    2128      301334 :             if (PQresultStatus(result) == PGRES_TUPLES_OK)
    2129      132056 :                 success &= SetupGOutput(&gfile_fout, &gfile_is_pipe);
    2130      301334 :             if (gfile_fout)
    2131          60 :                 tuples_fout = gfile_fout;
    2132      301334 :             if (success)
    2133      301118 :                 success &= PrintQueryResult(result, last, opt,
    2134             :                                             tuples_fout, printQueryFout);
    2135             :         }
    2136             : 
    2137             :         /* set variables from last result, unless dealt with elsewhere */
    2138      302418 :         if (last && !is_watch && !is_chunked_result)
    2139      300008 :             SetResultVariables(result, success);
    2140             : 
    2141      302418 :         ClearOrSaveResult(result);
    2142      302418 :         result = next_result;
    2143             : 
    2144      302418 :         if (cancel_pressed && PQpipelineStatus(pset.db) == PQ_PIPELINE_OFF)
    2145             :         {
    2146             :             /*
    2147             :              * Outside of a pipeline, drop the next result, as well as any
    2148             :              * others not yet read.
    2149             :              *
    2150             :              * Within a pipeline, we can let the outer loop handle this as an
    2151             :              * aborted pipeline, which will discard then all the results.
    2152             :              */
    2153           0 :             ClearOrSaveResult(result);
    2154           0 :             ClearOrSaveAllResults();
    2155           0 :             break;
    2156             :         }
    2157             :     }
    2158             : 
    2159             :     /* close \g file if we opened it */
    2160      341682 :     CloseGOutput(gfile_fout, gfile_is_pipe);
    2161             : 
    2162             :     if (end_pipeline)
    2163             :     {
    2164             :         /* after a pipeline is processed, pipeline piped_syncs should be 0 */
    2165             :         Assert(pset.piped_syncs == 0);
    2166             :         /* all commands have been processed */
    2167             :         Assert(pset.piped_commands == 0);
    2168             :         /* all results were read */
    2169             :         Assert(pset.available_results == 0);
    2170             :     }
    2171             :     Assert(pset.requested_results == 0);
    2172      341682 :     SetPipelineVariables();
    2173             : 
    2174             :     /* may need this to recover from conn loss during COPY */
    2175      341682 :     if (!CheckConnection())
    2176           0 :         return -1;
    2177             : 
    2178      341682 :     if (cancel_pressed || return_early)
    2179           4 :         return 0;
    2180             : 
    2181      341678 :     return success ? 1 : -1;
    2182             : }
    2183             : 
    2184             : 
    2185             : /*
    2186             :  * Advance the given char pointer over white space and SQL comments.
    2187             :  */
    2188             : static const char *
    2189         108 : skip_white_space(const char *query)
    2190             : {
    2191         108 :     int         cnestlevel = 0; /* slash-star comment nest level */
    2192             : 
    2193         132 :     while (*query)
    2194             :     {
    2195         132 :         int         mblen = PQmblenBounded(query, pset.encoding);
    2196             : 
    2197             :         /*
    2198             :          * Note: we assume the encoding is a superset of ASCII, so that for
    2199             :          * example "query[0] == '/'" is meaningful.  However, we do NOT assume
    2200             :          * that the second and subsequent bytes of a multibyte character
    2201             :          * couldn't look like ASCII characters; so it is critical to advance
    2202             :          * by mblen, not 1, whenever we haven't exactly identified the
    2203             :          * character we are skipping over.
    2204             :          */
    2205         132 :         if (isspace((unsigned char) *query))
    2206          24 :             query += mblen;
    2207         108 :         else if (query[0] == '/' && query[1] == '*')
    2208             :         {
    2209           0 :             cnestlevel++;
    2210           0 :             query += 2;
    2211             :         }
    2212         108 :         else if (cnestlevel > 0 && query[0] == '*' && query[1] == '/')
    2213             :         {
    2214           0 :             cnestlevel--;
    2215           0 :             query += 2;
    2216             :         }
    2217         108 :         else if (cnestlevel == 0 && query[0] == '-' && query[1] == '-')
    2218             :         {
    2219           0 :             query += 2;
    2220             : 
    2221             :             /*
    2222             :              * We have to skip to end of line since any slash-star inside the
    2223             :              * -- comment does NOT start a slash-star comment.
    2224             :              */
    2225           0 :             while (*query)
    2226             :             {
    2227           0 :                 if (*query == '\n')
    2228             :                 {
    2229           0 :                     query++;
    2230           0 :                     break;
    2231             :                 }
    2232           0 :                 query += PQmblenBounded(query, pset.encoding);
    2233             :             }
    2234             :         }
    2235         108 :         else if (cnestlevel > 0)
    2236           0 :             query += mblen;
    2237             :         else
    2238         108 :             break;              /* found first token */
    2239             :     }
    2240             : 
    2241         108 :     return query;
    2242             : }
    2243             : 
    2244             : 
    2245             : /*
    2246             :  * Check whether a command is one of those for which we should NOT start
    2247             :  * a new transaction block (ie, send a preceding BEGIN).
    2248             :  *
    2249             :  * These include the transaction control statements themselves, plus
    2250             :  * certain statements that the backend disallows inside transaction blocks.
    2251             :  */
    2252             : static bool
    2253          84 : command_no_begin(const char *query)
    2254             : {
    2255             :     int         wordlen;
    2256             : 
    2257             :     /*
    2258             :      * First we must advance over any whitespace and comments.
    2259             :      */
    2260          84 :     query = skip_white_space(query);
    2261             : 
    2262             :     /*
    2263             :      * Check word length (since "beginx" is not "begin").
    2264             :      */
    2265          84 :     wordlen = 0;
    2266         564 :     while (isalpha((unsigned char) query[wordlen]))
    2267         480 :         wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2268             : 
    2269             :     /*
    2270             :      * Transaction control commands.  These should include every keyword that
    2271             :      * gives rise to a TransactionStmt in the backend grammar, except for the
    2272             :      * savepoint-related commands.
    2273             :      *
    2274             :      * (We assume that START must be START TRANSACTION, since there is
    2275             :      * presently no other "START foo" command.)
    2276             :      */
    2277          84 :     if (wordlen == 5 && pg_strncasecmp(query, "abort", 5) == 0)
    2278           0 :         return true;
    2279          84 :     if (wordlen == 5 && pg_strncasecmp(query, "begin", 5) == 0)
    2280          12 :         return true;
    2281          72 :     if (wordlen == 5 && pg_strncasecmp(query, "start", 5) == 0)
    2282           0 :         return true;
    2283          72 :     if (wordlen == 6 && pg_strncasecmp(query, "commit", 6) == 0)
    2284           0 :         return true;
    2285          72 :     if (wordlen == 3 && pg_strncasecmp(query, "end", 3) == 0)
    2286           0 :         return true;
    2287          72 :     if (wordlen == 8 && pg_strncasecmp(query, "rollback", 8) == 0)
    2288           0 :         return true;
    2289          72 :     if (wordlen == 7 && pg_strncasecmp(query, "prepare", 7) == 0)
    2290             :     {
    2291             :         /* PREPARE TRANSACTION is a TC command, PREPARE foo is not */
    2292           0 :         query += wordlen;
    2293             : 
    2294           0 :         query = skip_white_space(query);
    2295             : 
    2296           0 :         wordlen = 0;
    2297           0 :         while (isalpha((unsigned char) query[wordlen]))
    2298           0 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2299             : 
    2300           0 :         if (wordlen == 11 && pg_strncasecmp(query, "transaction", 11) == 0)
    2301           0 :             return true;
    2302           0 :         return false;
    2303             :     }
    2304             : 
    2305             :     /*
    2306             :      * Commands not allowed within transactions.  The statements checked for
    2307             :      * here should be exactly those that call PreventInTransactionBlock() in
    2308             :      * the backend.
    2309             :      */
    2310          72 :     if (wordlen == 6 && pg_strncasecmp(query, "vacuum", 6) == 0)
    2311           0 :         return true;
    2312          72 :     if (wordlen == 7 && pg_strncasecmp(query, "cluster", 7) == 0)
    2313             :     {
    2314             :         /* CLUSTER with any arguments is allowed in transactions */
    2315           0 :         query += wordlen;
    2316             : 
    2317           0 :         query = skip_white_space(query);
    2318             : 
    2319           0 :         if (isalpha((unsigned char) query[0]))
    2320           0 :             return false;       /* has additional words */
    2321           0 :         return true;            /* it's CLUSTER without arguments */
    2322             :     }
    2323             : 
    2324          72 :     if (wordlen == 6 && pg_strncasecmp(query, "create", 6) == 0)
    2325             :     {
    2326          12 :         query += wordlen;
    2327             : 
    2328          12 :         query = skip_white_space(query);
    2329             : 
    2330          12 :         wordlen = 0;
    2331          72 :         while (isalpha((unsigned char) query[wordlen]))
    2332          60 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2333             : 
    2334          12 :         if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
    2335           0 :             return true;
    2336          12 :         if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
    2337           0 :             return true;
    2338             : 
    2339             :         /* CREATE [UNIQUE] INDEX CONCURRENTLY isn't allowed in xacts */
    2340          12 :         if (wordlen == 6 && pg_strncasecmp(query, "unique", 6) == 0)
    2341             :         {
    2342           0 :             query += wordlen;
    2343             : 
    2344           0 :             query = skip_white_space(query);
    2345             : 
    2346           0 :             wordlen = 0;
    2347           0 :             while (isalpha((unsigned char) query[wordlen]))
    2348           0 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2349             :         }
    2350             : 
    2351          12 :         if (wordlen == 5 && pg_strncasecmp(query, "index", 5) == 0)
    2352             :         {
    2353           0 :             query += wordlen;
    2354             : 
    2355           0 :             query = skip_white_space(query);
    2356             : 
    2357           0 :             wordlen = 0;
    2358           0 :             while (isalpha((unsigned char) query[wordlen]))
    2359           0 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2360             : 
    2361           0 :             if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
    2362           0 :                 return true;
    2363             :         }
    2364             : 
    2365          12 :         return false;
    2366             :     }
    2367             : 
    2368          60 :     if (wordlen == 5 && pg_strncasecmp(query, "alter", 5) == 0)
    2369             :     {
    2370           0 :         query += wordlen;
    2371             : 
    2372           0 :         query = skip_white_space(query);
    2373             : 
    2374           0 :         wordlen = 0;
    2375           0 :         while (isalpha((unsigned char) query[wordlen]))
    2376           0 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2377             : 
    2378             :         /* ALTER SYSTEM isn't allowed in xacts */
    2379           0 :         if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
    2380           0 :             return true;
    2381             : 
    2382           0 :         return false;
    2383             :     }
    2384             : 
    2385             :     /*
    2386             :      * Note: these tests will match DROP SYSTEM and REINDEX TABLESPACE, which
    2387             :      * aren't really valid commands so we don't care much. The other four
    2388             :      * possible matches are correct.
    2389             :      */
    2390          60 :     if ((wordlen == 4 && pg_strncasecmp(query, "drop", 4) == 0) ||
    2391           0 :         (wordlen == 7 && pg_strncasecmp(query, "reindex", 7) == 0))
    2392             :     {
    2393           6 :         query += wordlen;
    2394             : 
    2395           6 :         query = skip_white_space(query);
    2396             : 
    2397           6 :         wordlen = 0;
    2398          36 :         while (isalpha((unsigned char) query[wordlen]))
    2399          30 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2400             : 
    2401           6 :         if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
    2402           0 :             return true;
    2403           6 :         if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
    2404           0 :             return true;
    2405           6 :         if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
    2406           0 :             return true;
    2407          12 :         if (wordlen == 5 && (pg_strncasecmp(query, "index", 5) == 0 ||
    2408           6 :                              pg_strncasecmp(query, "table", 5) == 0))
    2409             :         {
    2410           6 :             query += wordlen;
    2411           6 :             query = skip_white_space(query);
    2412           6 :             wordlen = 0;
    2413          24 :             while (isalpha((unsigned char) query[wordlen]))
    2414          18 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2415             : 
    2416             :             /*
    2417             :              * REINDEX [ TABLE | INDEX ] CONCURRENTLY are not allowed in
    2418             :              * xacts.
    2419             :              */
    2420           6 :             if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
    2421           0 :                 return true;
    2422             :         }
    2423             : 
    2424             :         /* DROP INDEX CONCURRENTLY isn't allowed in xacts */
    2425           6 :         if (wordlen == 5 && pg_strncasecmp(query, "index", 5) == 0)
    2426             :         {
    2427           0 :             query += wordlen;
    2428             : 
    2429           0 :             query = skip_white_space(query);
    2430             : 
    2431           0 :             wordlen = 0;
    2432           0 :             while (isalpha((unsigned char) query[wordlen]))
    2433           0 :                 wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2434             : 
    2435           0 :             if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
    2436           0 :                 return true;
    2437             : 
    2438           0 :             return false;
    2439             :         }
    2440             : 
    2441           6 :         return false;
    2442             :     }
    2443             : 
    2444             :     /* DISCARD ALL isn't allowed in xacts, but other variants are allowed. */
    2445          54 :     if (wordlen == 7 && pg_strncasecmp(query, "discard", 7) == 0)
    2446             :     {
    2447           0 :         query += wordlen;
    2448             : 
    2449           0 :         query = skip_white_space(query);
    2450             : 
    2451           0 :         wordlen = 0;
    2452           0 :         while (isalpha((unsigned char) query[wordlen]))
    2453           0 :             wordlen += PQmblenBounded(&query[wordlen], pset.encoding);
    2454             : 
    2455           0 :         if (wordlen == 3 && pg_strncasecmp(query, "all", 3) == 0)
    2456           0 :             return true;
    2457           0 :         return false;
    2458             :     }
    2459             : 
    2460          54 :     return false;
    2461             : }
    2462             : 
    2463             : 
    2464             : /*
    2465             :  * Test if the current user is a database superuser.
    2466             :  */
    2467             : bool
    2468         116 : is_superuser(void)
    2469             : {
    2470             :     const char *val;
    2471             : 
    2472         116 :     if (!pset.db)
    2473           0 :         return false;
    2474             : 
    2475         116 :     val = PQparameterStatus(pset.db, "is_superuser");
    2476             : 
    2477         116 :     if (val && strcmp(val, "on") == 0)
    2478         116 :         return true;
    2479             : 
    2480           0 :     return false;
    2481             : }
    2482             : 
    2483             : 
    2484             : /*
    2485             :  * Test if the current session uses standard string literals.
    2486             :  */
    2487             : bool
    2488      656208 : standard_strings(void)
    2489             : {
    2490             :     const char *val;
    2491             : 
    2492      656208 :     if (!pset.db)
    2493           0 :         return false;
    2494             : 
    2495      656208 :     val = PQparameterStatus(pset.db, "standard_conforming_strings");
    2496             : 
    2497      656208 :     if (val && strcmp(val, "on") == 0)
    2498      656016 :         return true;
    2499             : 
    2500         192 :     return false;
    2501             : }
    2502             : 
    2503             : 
    2504             : /*
    2505             :  * Return the session user of the current connection.
    2506             :  */
    2507             : const char *
    2508           0 : session_username(void)
    2509             : {
    2510             :     const char *val;
    2511             : 
    2512           0 :     if (!pset.db)
    2513           0 :         return NULL;
    2514             : 
    2515           0 :     val = PQparameterStatus(pset.db, "session_authorization");
    2516           0 :     if (val)
    2517           0 :         return val;
    2518             :     else
    2519           0 :         return PQuser(pset.db);
    2520             : }
    2521             : 
    2522             : 
    2523             : /* expand_tilde
    2524             :  *
    2525             :  * substitute '~' with HOME or '~username' with username's home dir
    2526             :  *
    2527             :  */
    2528             : void
    2529         184 : expand_tilde(char **filename)
    2530             : {
    2531         184 :     if (!filename || !(*filename))
    2532          18 :         return;
    2533             : 
    2534             :     /*
    2535             :      * WIN32 doesn't use tilde expansion for file names. Also, it uses tilde
    2536             :      * for short versions of long file names, though the tilde is usually
    2537             :      * toward the end, not at the beginning.
    2538             :      */
    2539             : #ifndef WIN32
    2540             : 
    2541             :     /* try tilde expansion */
    2542         166 :     if (**filename == '~')
    2543             :     {
    2544             :         char       *fn;
    2545             :         char        oldp,
    2546             :                    *p;
    2547             :         struct passwd *pw;
    2548             :         char        home[MAXPGPATH];
    2549             : 
    2550           0 :         fn = *filename;
    2551           0 :         *home = '\0';
    2552             : 
    2553           0 :         p = fn + 1;
    2554           0 :         while (*p != '/' && *p != '\0')
    2555           0 :             p++;
    2556             : 
    2557           0 :         oldp = *p;
    2558           0 :         *p = '\0';
    2559             : 
    2560           0 :         if (*(fn + 1) == '\0')
    2561           0 :             get_home_path(home);    /* ~ or ~/ only */
    2562           0 :         else if ((pw = getpwnam(fn + 1)) != NULL)
    2563           0 :             strlcpy(home, pw->pw_dir, sizeof(home)); /* ~user */
    2564             : 
    2565           0 :         *p = oldp;
    2566           0 :         if (strlen(home) != 0)
    2567             :         {
    2568             :             char       *newfn;
    2569             : 
    2570           0 :             newfn = psprintf("%s%s", home, p);
    2571           0 :             free(fn);
    2572           0 :             *filename = newfn;
    2573             :         }
    2574             :     }
    2575             : #endif
    2576             : }
    2577             : 
    2578             : /*
    2579             :  * Checks if connection string starts with either of the valid URI prefix
    2580             :  * designators.
    2581             :  *
    2582             :  * Returns the URI prefix length, 0 if the string doesn't contain a URI prefix.
    2583             :  *
    2584             :  * XXX This is a duplicate of the eponymous libpq function.
    2585             :  */
    2586             : static int
    2587          44 : uri_prefix_length(const char *connstr)
    2588             : {
    2589             :     /* The connection URI must start with either of the following designators: */
    2590             :     static const char uri_designator[] = "postgresql://";
    2591             :     static const char short_uri_designator[] = "postgres://";
    2592             : 
    2593          44 :     if (strncmp(connstr, uri_designator,
    2594             :                 sizeof(uri_designator) - 1) == 0)
    2595           0 :         return sizeof(uri_designator) - 1;
    2596             : 
    2597          44 :     if (strncmp(connstr, short_uri_designator,
    2598             :                 sizeof(short_uri_designator) - 1) == 0)
    2599           0 :         return sizeof(short_uri_designator) - 1;
    2600             : 
    2601          44 :     return 0;
    2602             : }
    2603             : 
    2604             : /*
    2605             :  * Reset state related to extended query protocol
    2606             :  *
    2607             :  * Clean up any state related to bind parameters, statement name and
    2608             :  * PSQL_SEND_MODE.  This needs to be called after processing a query or when
    2609             :  * running a new meta-command that uses the extended query protocol, like
    2610             :  * \parse, \bind, etc.
    2611             :  */
    2612             : void
    2613      344366 : clean_extended_state(void)
    2614             : {
    2615             :     int         i;
    2616             : 
    2617      344366 :     switch (pset.send_mode)
    2618             :     {
    2619          36 :         case PSQL_SEND_EXTENDED_CLOSE:  /* \close */
    2620          36 :             free(pset.stmtName);
    2621          36 :             break;
    2622          96 :         case PSQL_SEND_EXTENDED_PARSE:  /* \parse */
    2623          96 :             free(pset.stmtName);
    2624          96 :             break;
    2625         866 :         case PSQL_SEND_EXTENDED_QUERY_PARAMS:   /* \bind */
    2626             :         case PSQL_SEND_EXTENDED_QUERY_PREPARED: /* \bind_named */
    2627        1564 :             for (i = 0; i < pset.bind_nparams; i++)
    2628         698 :                 free(pset.bind_params[i]);
    2629         866 :             free(pset.bind_params);
    2630         866 :             free(pset.stmtName);
    2631         866 :             pset.bind_params = NULL;
    2632         866 :             break;
    2633      343368 :         case PSQL_SEND_QUERY:
    2634             :         case PSQL_SEND_START_PIPELINE_MODE: /* \startpipeline */
    2635             :         case PSQL_SEND_END_PIPELINE_MODE:   /* \endpipeline */
    2636             :         case PSQL_SEND_PIPELINE_SYNC:   /* \syncpipeline */
    2637             :         case PSQL_SEND_FLUSH:   /* \flush */
    2638             :         case PSQL_SEND_GET_RESULTS: /* \getresults */
    2639             :         case PSQL_SEND_FLUSH_REQUEST:   /* \flushrequest */
    2640      343368 :             break;
    2641             :     }
    2642             : 
    2643      344366 :     pset.stmtName = NULL;
    2644      344366 :     pset.send_mode = PSQL_SEND_QUERY;
    2645      344366 : }
    2646             : 
    2647             : /*
    2648             :  * Recognized connection string either starts with a valid URI prefix or
    2649             :  * contains a "=" in it.
    2650             :  *
    2651             :  * Must be consistent with parse_connection_string: anything for which this
    2652             :  * returns true should at least look like it's parseable by that routine.
    2653             :  *
    2654             :  * XXX This is a duplicate of the eponymous libpq function.
    2655             :  */
    2656             : bool
    2657          44 : recognized_connection_string(const char *connstr)
    2658             : {
    2659          44 :     return uri_prefix_length(connstr) != 0 || strchr(connstr, '=') != NULL;
    2660             : }

Generated by: LCOV version 1.16