#include "postgres_fe.h"
#include <ctype.h>
#include <fcntl.h>
#include <limits.h>
#include <unistd.h>
#include "libpq-fe.h"
#include "libpq-int.h"
#include "mb/pg_wchar.h"

Include dependency graph for fe-exec.c:

Macros
#define	PGRESULT_DATA_BLOCKSIZE 2048

#define	PGRESULT_ALIGN_BOUNDARY MAXIMUM_ALIGNOF /* from configure */

#define	PGRESULT_BLOCK_OVERHEAD Max(sizeof(PGresult_data), PGRESULT_ALIGN_BOUNDARY)

#define	PGRESULT_SEP_ALLOC_THRESHOLD (PGRESULT_DATA_BLOCKSIZE / 2)

#define	ISFIRSTOCTDIGIT(CH) ((CH) >= '0' && (CH) <= '3')

#define	ISOCTDIGIT(CH) ((CH) >= '0' && (CH) <= '7')

#define	OCTVAL(CH) ((CH) - '0')

Functions
static PGEvent *	dupEvents (PGEvent events, int count, size_t memSize)

static bool	pqAddTuple (PGresult res, PGresAttValue tup, const char **errmsgp)

static int	PQsendQueryInternal (PGconn conn, const char query, bool newQuery)

static bool	PQsendQueryStart (PGconn *conn, bool newQuery)

static int	PQsendQueryGuts (PGconn conn, const char command, const char stmtName, int nParams, const Oid paramTypes, const char const paramValues, const int paramLengths, const int paramFormats, int resultFormat)

static void	parseInput (PGconn *conn)

static PGresult *	getCopyResult (PGconn *conn, ExecStatusType copytype)

static bool	PQexecStart (PGconn *conn)

static PGresult *	PQexecFinish (PGconn *conn)

static int	PQsendTypedCommand (PGconn conn, char command, char type, const char target)

static int	check_field_number (const PGresult *res, int field_num)

static void	pqPipelineProcessQueue (PGconn *conn)

static int	pqPipelineFlush (PGconn *conn)

PGresult *	PQmakeEmptyPGresult (PGconn *conn, ExecStatusType status)

int	PQsetResultAttrs (PGresult res, int numAttributes, PGresAttDesc attDescs)

PGresult *	PQcopyResult (const PGresult *src, int flags)

int	PQsetvalue (PGresult res, int tup_num, int field_num, char value, int len)

void *	PQresultAlloc (PGresult *res, size_t nBytes)

void *	pqResultAlloc (PGresult *res, size_t nBytes, bool isBinary)

size_t	PQresultMemorySize (const PGresult *res)

char *	pqResultStrdup (PGresult res, const char str)

void	pqSetResultError (PGresult *res, PQExpBuffer errorMessage, int offset)

void	PQclear (PGresult *res)

void	pqClearAsyncResult (PGconn *conn)

void	pqSaveErrorResult (PGconn *conn)

static void	pqSaveWriteError (PGconn *conn)

PGresult *	pqPrepareAsyncResult (PGconn *conn)

void	pqInternalNotice (const PGNoticeHooks hooks, const char fmt,...)

void	pqSaveMessageField (PGresult res, char code, const char value)

void	pqSaveParameterStatus (PGconn conn, const char name, const char *value)

int	pqRowProcessor (PGconn conn, const char *errmsgp)

static PGcmdQueueEntry *	pqAllocCmdQueueEntry (PGconn *conn)

static void	pqAppendCmdQueueEntry (PGconn conn, PGcmdQueueEntry entry)

static void	pqRecycleCmdQueueEntry (PGconn conn, PGcmdQueueEntry entry)

int	PQsendQuery (PGconn conn, const char query)

int	PQsendQueryContinue (PGconn conn, const char query)

int	PQsendQueryParams (PGconn conn, const char command, int nParams, const Oid paramTypes, const char const paramValues, const int paramLengths, const int *paramFormats, int resultFormat)

int	PQsendPrepare (PGconn conn, const char stmtName, const char query, int nParams, const Oid paramTypes)

int	PQsendQueryPrepared (PGconn conn, const char stmtName, int nParams, const char const paramValues, const int paramLengths, const int paramFormats, int resultFormat)

int	PQsetSingleRowMode (PGconn *conn)

int	PQconsumeInput (PGconn *conn)

int	PQisBusy (PGconn *conn)

PGresult *	PQgetResult (PGconn *conn)

PGresult *	PQexec (PGconn conn, const char query)

PGresult *	PQexecParams (PGconn conn, const char command, int nParams, const Oid paramTypes, const char const paramValues, const int paramLengths, const int *paramFormats, int resultFormat)

PGresult *	PQprepare (PGconn conn, const char stmtName, const char query, int nParams, const Oid paramTypes)

PGresult *	PQexecPrepared (PGconn conn, const char stmtName, int nParams, const char const paramValues, const int paramLengths, const int paramFormats, int resultFormat)

PGresult *	PQdescribePrepared (PGconn conn, const char stmt)

PGresult *	PQdescribePortal (PGconn conn, const char portal)

int	PQsendDescribePrepared (PGconn conn, const char stmt)

int	PQsendDescribePortal (PGconn conn, const char portal)

PGresult *	PQclosePrepared (PGconn conn, const char stmt)

PGresult *	PQclosePortal (PGconn conn, const char portal)

int	PQsendClosePrepared (PGconn conn, const char stmt)

int	PQsendClosePortal (PGconn conn, const char portal)

PGnotify *	PQnotifies (PGconn *conn)

int	PQputCopyData (PGconn conn, const char buffer, int nbytes)

int	PQputCopyEnd (PGconn conn, const char errormsg)

int	PQgetCopyData (PGconn conn, char *buffer, int async)

int	PQgetline (PGconn conn, char buffer, int length)

int	PQgetlineAsync (PGconn conn, char buffer, int bufsize)

int	PQputline (PGconn conn, const char string)

int	PQputnbytes (PGconn conn, const char buffer, int nbytes)

int	PQendcopy (PGconn *conn)

PGresult *	PQfn (PGconn conn, int fnid, int result_buf, int result_len, int result_is_int, const PQArgBlock args, int nargs)

int	PQenterPipelineMode (PGconn *conn)

int	PQexitPipelineMode (PGconn *conn)

void	pqCommandQueueAdvance (PGconn *conn)

int	PQpipelineSync (PGconn *conn)

int	PQsendFlushRequest (PGconn *conn)

ExecStatusType	PQresultStatus (const PGresult *res)

char *	PQresStatus (ExecStatusType status)

char *	PQresultErrorMessage (const PGresult *res)

char *	PQresultVerboseErrorMessage (const PGresult *res, PGVerbosity verbosity, PGContextVisibility show_context)

char *	PQresultErrorField (const PGresult *res, int fieldcode)

int	PQntuples (const PGresult *res)

int	PQnfields (const PGresult *res)

int	PQbinaryTuples (const PGresult *res)

static int	check_tuple_field_number (const PGresult *res, int tup_num, int field_num)

static int	check_param_number (const PGresult *res, int param_num)

char *	PQfname (const PGresult *res, int field_num)

int	PQfnumber (const PGresult res, const char field_name)

Oid	PQftable (const PGresult *res, int field_num)

int	PQftablecol (const PGresult *res, int field_num)

int	PQfformat (const PGresult *res, int field_num)

Oid	PQftype (const PGresult *res, int field_num)

int	PQfsize (const PGresult *res, int field_num)

int	PQfmod (const PGresult *res, int field_num)

char *	PQcmdStatus (PGresult *res)

char *	PQoidStatus (const PGresult *res)

Oid	PQoidValue (const PGresult *res)

char *	PQcmdTuples (PGresult *res)

char *	PQgetvalue (const PGresult *res, int tup_num, int field_num)

int	PQgetlength (const PGresult *res, int tup_num, int field_num)

int	PQgetisnull (const PGresult *res, int tup_num, int field_num)

int	PQnparams (const PGresult *res)

Oid	PQparamtype (const PGresult *res, int param_num)

int	PQsetnonblocking (PGconn *conn, int arg)

int	PQisnonblocking (const PGconn *conn)

int	PQisthreadsafe (void)

int	PQflush (PGconn *conn)

void	PQfreemem (void *ptr)

void	PQfreeNotify (PGnotify *notify)

static size_t	PQescapeStringInternal (PGconn conn, char to, const char from, size_t length, int error, int encoding, bool std_strings)

size_t	PQescapeStringConn (PGconn conn, char to, const char from, size_t length, int error)

size_t	PQescapeString (char to, const char from, size_t length)

static char *	PQescapeInternal (PGconn conn, const char str, size_t len, bool as_ident)

char *	PQescapeLiteral (PGconn conn, const char str, size_t len)

char *	PQescapeIdentifier (PGconn conn, const char str, size_t len)

static char	get_hex (char c)

static unsigned char *	PQescapeByteaInternal (PGconn conn, const unsigned char from, size_t from_length, size_t *to_length, bool std_strings, bool use_hex)

unsigned char *	PQescapeByteaConn (PGconn conn, const unsigned char from, size_t from_length, size_t *to_length)

unsigned char *	PQescapeBytea (const unsigned char from, size_t from_length, size_t to_length)

unsigned char *	PQunescapeBytea (const unsigned char strtext, size_t retbuflen)

Variables
char *const	pgresStatus []

static const PGresult	OOM_result

static int	static_client_encoding = PG_SQL_ASCII

static bool	static_std_strings = false

static const char	hextbl [] = "0123456789abcdef"

static const int8	hexlookup [128]

Macro Definition Documentation

◆ ISFIRSTOCTDIGIT

#define ISFIRSTOCTDIGIT ( CH ) ((CH) >= '0' && (CH) <= '3')

Definition at line 4391 of file fe-exec.c.

◆ ISOCTDIGIT

#define ISOCTDIGIT ( CH ) ((CH) >= '0' && (CH) <= '7')

Definition at line 4392 of file fe-exec.c.

◆ OCTVAL

#define OCTVAL ( CH ) ((CH) - '0')

Definition at line 4393 of file fe-exec.c.

◆ PGRESULT_ALIGN_BOUNDARY

#define PGRESULT_ALIGN_BOUNDARY MAXIMUM_ALIGNOF /* from configure */

Definition at line 141 of file fe-exec.c.

◆ PGRESULT_BLOCK_OVERHEAD

#define PGRESULT_BLOCK_OVERHEAD Max(sizeof(PGresult_data), PGRESULT_ALIGN_BOUNDARY)

Definition at line 142 of file fe-exec.c.

◆ PGRESULT_DATA_BLOCKSIZE

#define PGRESULT_DATA_BLOCKSIZE 2048

Definition at line 140 of file fe-exec.c.

◆ PGRESULT_SEP_ALLOC_THRESHOLD

#define PGRESULT_SEP_ALLOC_THRESHOLD (PGRESULT_DATA_BLOCKSIZE / 2)

Definition at line 143 of file fe-exec.c.

Function Documentation

◆ check_field_number()

static int check_field_number	(	const PGresult *	res,
		int	field_num
	)

static

Definition at line 3424 of file fe-exec.c.

 {
     if (!res)
         return false;           /* no way to display error message... */
     if (field_num < 0 || field_num >= res->numAttributes)
     {
         pqInternalNotice(&res->noticeHooks,
                          "column number %d is out of range 0..%d",
                          field_num, res->numAttributes - 1);
         return false;
     }
     return true;
 }

References pg_result::noticeHooks, pg_result::numAttributes, pqInternalNotice(), and res.

Referenced by PQfformat(), PQfmod(), PQfname(), PQfsize(), PQftable(), PQftablecol(), PQftype(), and PQsetvalue().

◆ check_param_number()

static int check_param_number	(	const PGresult *	res,
		int	param_num
	)

static

Definition at line 3462 of file fe-exec.c.

 {
     if (!res)
         return false;           /* no way to display error message... */
     if (param_num < 0 || param_num >= res->numParameters)
     {
         pqInternalNotice(&res->noticeHooks,
                          "parameter number %d is out of range 0..%d",
                          param_num, res->numParameters - 1);
         return false;
     }
  
     return true;
 }

References pg_result::noticeHooks, pg_result::numParameters, pqInternalNotice(), and res.

Referenced by PQparamtype().

◆ check_tuple_field_number()

static int check_tuple_field_number	(	const PGresult *	res,
		int	tup_num,
		int	field_num
	)

static

Definition at line 3439 of file fe-exec.c.

 {
     if (!res)
         return false;           /* no way to display error message... */
     if (tup_num < 0 || tup_num >= res->ntups)
     {
         pqInternalNotice(&res->noticeHooks,
                          "row number %d is out of range 0..%d",
                          tup_num, res->ntups - 1);
         return false;
     }
     if (field_num < 0 || field_num >= res->numAttributes)
     {
         pqInternalNotice(&res->noticeHooks,
                          "column number %d is out of range 0..%d",
                          field_num, res->numAttributes - 1);
         return false;
     }
     return true;
 }

References pg_result::noticeHooks, pg_result::ntups, pg_result::numAttributes, pqInternalNotice(), and res.

Referenced by PQgetisnull(), PQgetlength(), and PQgetvalue().

◆ dupEvents()

static PGEvent * dupEvents	(	PGEvent *	events,
		int	count,
		size_t *	memSize
	)

static

Definition at line 405 of file fe-exec.c.

 {
     PGEvent    *newEvents;
     size_t      msize;
     int         i;
  
     if (!events || count <= 0)
         return NULL;
  
     msize = count * sizeof(PGEvent);
     newEvents = (PGEvent *) malloc(msize);
     if (!newEvents)
         return NULL;
  
     for (i = 0; i < count; i++)
     {
         newEvents[i].proc = events[i].proc;
         newEvents[i].passThrough = events[i].passThrough;
         newEvents[i].data = NULL;
         newEvents[i].resultInitialized = false;
         newEvents[i].name = strdup(events[i].name);
         if (!newEvents[i].name)
         {
             while (--i >= 0)
                 free(newEvents[i].name);
             free(newEvents);
             return NULL;
         }
         msize += strlen(events[i].name) + 1;
     }
  
     *memSize += msize;
     return newEvents;
 }

References PGEvent::data, free, i, malloc, name, PGEvent::name, PGEvent::passThrough, PGEvent::proc, and PGEvent::resultInitialized.

Referenced by PQcopyResult(), and PQmakeEmptyPGresult().

◆ get_hex()

static char get_hex ( char c )

inlinestatic

Definition at line 4244 of file fe-exec.c.

 {
     int         res = -1;
  
     if (c > 0 && c < 127)
         res = hexlookup[(unsigned char) c];
  
     return (char) res;
 }

References hexlookup, and res.

Referenced by PQunescapeBytea().

◆ getCopyResult()

static PGresult * getCopyResult	(	PGconn *	conn,
		ExecStatusType	copytype
	)

static

Definition at line 2190 of file fe-exec.c.

 {
     /*
      * If the server connection has been lost, don't pretend everything is
      * hunky-dory; instead return a PGRES_FATAL_ERROR result, and reset the
      * asyncStatus to idle (corresponding to what we'd do if we'd detected I/O
      * error in the earlier steps in PQgetResult).  The text returned in the
      * result is whatever is in conn->errorMessage; we hope that was filled
      * with something relevant when the lost connection was detected.
      */
     if (conn->status != CONNECTION_OK)
     {
         pqSaveErrorResult(conn);
         conn->asyncStatus = PGASYNC_IDLE;
         return pqPrepareAsyncResult(conn);
     }
  
     /* If we have an async result for the COPY, return that */
     if (conn->result && conn->result->resultStatus == copytype)
         return pqPrepareAsyncResult(conn);
  
     /* Otherwise, invent a suitable PGresult */
     return PQmakeEmptyPGresult(conn, copytype);
 }

References pg_conn::asyncStatus, conn, CONNECTION_OK, PGASYNC_IDLE, PQmakeEmptyPGresult(), pqPrepareAsyncResult(), pqSaveErrorResult(), pg_conn::result, pg_result::resultStatus, and pg_conn::status.

Referenced by PQgetResult().

◆ parseInput()

static void parseInput ( PGconn * conn )

static

Definition at line 1993 of file fe-exec.c.

 {
     pqParseInput3(conn);
 }

References conn, and pqParseInput3().

Referenced by PQgetResult(), PQisBusy(), PQnotifies(), and PQputCopyData().

◆ pqAddTuple()

static bool pqAddTuple	(	PGresult *	res,
		PGresAttValue *	tup,
		const char **	errmsgp
	)

static

Definition at line 988 of file fe-exec.c.

 {
     if (res->ntups >= res->tupArrSize)
     {
         /*
          * Try to grow the array.
          *
          * We can use realloc because shallow copying of the structure is
          * okay. Note that the first time through, res->tuples is NULL. While
          * ANSI says that realloc() should act like malloc() in that case,
          * some old C libraries (like SunOS 4.1.x) coredump instead. On
          * failure realloc is supposed to return NULL without damaging the
          * existing allocation. Note that the positions beyond res->ntups are
          * garbage, not necessarily NULL.
          */
         int         newSize;
         PGresAttValue **newTuples;
  
         /*
          * Since we use integers for row numbers, we can't support more than
          * INT_MAX rows.  Make sure we allow that many, though.
          */
         if (res->tupArrSize <= INT_MAX / 2)
             newSize = (res->tupArrSize > 0) ? res->tupArrSize * 2 : 128;
         else if (res->tupArrSize < INT_MAX)
             newSize = INT_MAX;
         else
         {
             *errmsgp = libpq_gettext("PGresult cannot support more than INT_MAX tuples");
             return false;
         }
  
         /*
          * Also, on 32-bit platforms we could, in theory, overflow size_t even
          * before newSize gets to INT_MAX.  (In practice we'd doubtless hit
          * OOM long before that, but let's check.)
          */
 #if INT_MAX >= (SIZE_MAX / 2)
         if (newSize > SIZE_MAX / sizeof(PGresAttValue *))
         {
             *errmsgp = libpq_gettext("size_t overflow");
             return false;
         }
 #endif
  
         if (res->tuples == NULL)
             newTuples = (PGresAttValue **)
                 malloc(newSize * sizeof(PGresAttValue *));
         else
             newTuples = (PGresAttValue **)
                 realloc(res->tuples, newSize * sizeof(PGresAttValue *));
         if (!newTuples)
             return false;       /* malloc or realloc failed */
         res->memorySize +=
             (newSize - res->tupArrSize) * sizeof(PGresAttValue *);
         res->tupArrSize = newSize;
         res->tuples = newTuples;
     }
     res->tuples[res->ntups] = tup;
     res->ntups++;
     return true;
 }

References if(), libpq_gettext, malloc, pg_result::memorySize, pg_result::ntups, realloc, res, pg_result::tupArrSize, and pg_result::tuples.

Referenced by pqRowProcessor(), and PQsetvalue().

◆ pqAllocCmdQueueEntry()

static PGcmdQueueEntry* pqAllocCmdQueueEntry ( PGconn * conn )

static

Definition at line 1312 of file fe-exec.c.

 {
     PGcmdQueueEntry *entry;
  
     if (conn->cmd_queue_recycle == NULL)
     {
         entry = (PGcmdQueueEntry *) malloc(sizeof(PGcmdQueueEntry));
         if (entry == NULL)
         {
             libpq_append_conn_error(conn, "out of memory");
             return NULL;
         }
     }
     else
     {
         entry = conn->cmd_queue_recycle;
         conn->cmd_queue_recycle = entry->next;
     }
     entry->next = NULL;
     entry->query = NULL;
  
     return entry;
 }

References pg_conn::cmd_queue_recycle, conn, libpq_append_conn_error(), malloc, PGcmdQueueEntry::next, and PGcmdQueueEntry::query.

Referenced by PQpipelineSync(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and PQsendTypedCommand().

◆ pqAppendCmdQueueEntry()

static void pqAppendCmdQueueEntry	(	PGconn *	conn,
		PGcmdQueueEntry *	entry
	)

static

Definition at line 1345 of file fe-exec.c.

 {
     Assert(entry->next == NULL);
  
     if (conn->cmd_queue_head == NULL)
         conn->cmd_queue_head = entry;
     else
         conn->cmd_queue_tail->next = entry;
  
     conn->cmd_queue_tail = entry;
  
     switch (conn->pipelineStatus)
     {
         case PQ_PIPELINE_OFF:
         case PQ_PIPELINE_ON:
  
             /*
              * When not in pipeline aborted state, if there's a result ready
              * to be consumed, let it be so (that is, don't change away from
              * READY or READY_MORE); otherwise set us busy to wait for
              * something to arrive from the server.
              */
             if (conn->asyncStatus == PGASYNC_IDLE)
                 conn->asyncStatus = PGASYNC_BUSY;
             break;
  
         case PQ_PIPELINE_ABORTED:
  
             /*
              * In aborted pipeline state, we don't expect anything from the
              * server (since we don't send any queries that are queued).
              * Therefore, if IDLE then do what PQgetResult would do to let
              * itself consume commands from the queue; if we're in any other
              * state, we don't have to do anything.
              */
             if (conn->asyncStatus == PGASYNC_IDLE ||
                 conn->asyncStatus == PGASYNC_PIPELINE_IDLE)
                 pqPipelineProcessQueue(conn);
             break;
     }
 }

References Assert(), pg_conn::asyncStatus, pg_conn::cmd_queue_head, pg_conn::cmd_queue_tail, conn, PGcmdQueueEntry::next, PGASYNC_BUSY, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, pg_conn::pipelineStatus, PQ_PIPELINE_ABORTED, PQ_PIPELINE_OFF, PQ_PIPELINE_ON, and pqPipelineProcessQueue().

Referenced by PQpipelineSync(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and PQsendTypedCommand().

◆ PQbinaryTuples()

int PQbinaryTuples ( const PGresult * res )

Definition at line 3411 of file fe-exec.c.

 {
     if (!res)
         return 0;
     return res->binary;
 }

References pg_result::binary, and res.

Referenced by HandleCopyResult().

◆ PQclear()

void PQclear ( PGresult * res )

Definition at line 718 of file fe-exec.c.

 {
     PGresult_data *block;
     int         i;
  
     /* As a convenience, do nothing for a NULL pointer */
     if (!res)
         return;
     /* Also, do nothing if the argument is OOM_result */
     if ((const PGresult *) res == &OOM_result)
         return;
  
     /* Close down any events we may have */
     for (i = 0; i < res->nEvents; i++)
     {
         /* only send DESTROY to successfully-initialized event procs */
         if (res->events[i].resultInitialized)
         {
             PGEventResultDestroy evt;
  
             evt.result = res;
             (void) res->events[i].proc(PGEVT_RESULTDESTROY, &evt,
                                        res->events[i].passThrough);
         }
         free(res->events[i].name);
     }
  
     free(res->events);
  
     /* Free all the subsidiary blocks */
     while ((block = res->curBlock) != NULL)
     {
         res->curBlock = block->next;
         free(block);
     }
  
     /* Free the top-level tuple pointer array */
     free(res->tuples);
  
     /* zero out the pointer fields to catch programming errors */
     res->attDescs = NULL;
     res->tuples = NULL;
     res->paramDescs = NULL;
     res->errFields = NULL;
     res->events = NULL;
     res->nEvents = 0;
     /* res->curBlock was zeroed out earlier */
  
     /* Free the PGresult structure itself */
     free(res);
 }

References pg_result::attDescs, pg_result::curBlock, pg_result::errFields, pg_result::events, free, i, PGEvent::name, pg_result::nEvents, pgresult_data::next, OOM_result, pg_result::paramDescs, PGEvent::passThrough, PGEVT_RESULTDESTROY, PGEvent::proc, res, PGEventResultDestroy::result, PGEvent::resultInitialized, and pg_result::tuples.

Referenced by pqClearAsyncResult(), PQcopyResult(), PQexecFinish(), PQexecStart(), pqInternalNotice(), PQmakeEmptyPGresult(), and pqRowProcessor().

◆ pqClearAsyncResult()

void pqClearAsyncResult ( PGconn * conn )

Definition at line 776 of file fe-exec.c.

 {
     PQclear(conn->result);
     conn->result = NULL;
     conn->error_result = false;
     PQclear(conn->next_result);
     conn->next_result = NULL;
 }

References conn, pg_conn::error_result, pg_conn::next_result, PQclear(), and pg_conn::result.

Referenced by closePGconn(), getAnotherTuple(), getParamDescriptions(), getRowDescriptions(), PQconnectPoll(), pqGetErrorNotice3(), pqPipelineProcessQueue(), pqSaveErrorResult(), and PQsendQueryStart().

◆ PQclosePortal()

PGresult* PQclosePortal	(	PGconn *	conn,
		const char *	portal
	)

Definition at line 2505 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendTypedCommand(conn, PqMsg_Close, 'P', portal))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), PqMsg_Close, and PQsendTypedCommand().

Referenced by test_prepared().

◆ PQclosePrepared()

PGresult* PQclosePrepared	(	PGconn *	conn,
		const char *	stmt
	)

Definition at line 2487 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendTypedCommand(conn, PqMsg_Close, 'S', stmt))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), PqMsg_Close, PQsendTypedCommand(), and stmt.

Referenced by test_prepared().

◆ PQcmdStatus()

char* PQcmdStatus ( PGresult * res )

Definition at line 3666 of file fe-exec.c.

 {
     if (!res)
         return NULL;
     return res->cmdStatus;
 }

References pg_result::cmdStatus, and res.

Referenced by dblink_exec(), ecpg_process_output(), ExecQueryAndProcessResults(), materializeResult(), PrintQueryResult(), PrintQueryStatus(), and test_pipelined_insert().

◆ PQcmdTuples()

char* PQcmdTuples ( PGresult * res )

Definition at line 3736 of file fe-exec.c.

 {
     char       *p,
                *c;
  
     if (!res)
         return "";
  
     if (strncmp(res->cmdStatus, "INSERT ", 7) == 0)
     {
         p = res->cmdStatus + 7;
         /* INSERT: skip oid and space */
         while (*p && *p != ' ')
             p++;
         if (*p == 0)
             goto interpret_error;   /* no space? */
         p++;
     }
     else if (strncmp(res->cmdStatus, "SELECT ", 7) == 0 ||
              strncmp(res->cmdStatus, "DELETE ", 7) == 0 ||
              strncmp(res->cmdStatus, "UPDATE ", 7) == 0)
         p = res->cmdStatus + 7;
     else if (strncmp(res->cmdStatus, "FETCH ", 6) == 0 ||
              strncmp(res->cmdStatus, "MERGE ", 6) == 0)
         p = res->cmdStatus + 6;
     else if (strncmp(res->cmdStatus, "MOVE ", 5) == 0 ||
              strncmp(res->cmdStatus, "COPY ", 5) == 0)
         p = res->cmdStatus + 5;
     else
         return "";
  
     /* check that we have an integer (at least one digit, nothing else) */
     for (c = p; *c; c++)
     {
         if (!isdigit((unsigned char) *c))
             goto interpret_error;
     }
     if (c == p)
         goto interpret_error;
  
     return p;
  
 interpret_error:
     pqInternalNotice(&res->noticeHooks,
                      "could not interpret result from server: %s",
                      res->cmdStatus);
     return "";
 }

References pg_result::cmdStatus, pg_result::noticeHooks, pqInternalNotice(), and res.

Referenced by ecpg_process_output(), execute_dml_stmt(), execute_foreign_modify(), and SetResultVariables().

◆ pqCommandQueueAdvance()

void pqCommandQueueAdvance ( PGconn * conn )

Definition at line 3095 of file fe-exec.c.

 {
     PGcmdQueueEntry *prevquery;
  
     if (conn->cmd_queue_head == NULL)
         return;
  
     /* delink from queue */
     prevquery = conn->cmd_queue_head;
     conn->cmd_queue_head = conn->cmd_queue_head->next;
  
     /* If the queue is now empty, reset the tail too */
     if (conn->cmd_queue_head == NULL)
         conn->cmd_queue_tail = NULL;
  
     /* and make it recyclable */
     prevquery->next = NULL;
     pqRecycleCmdQueueEntry(conn, prevquery);
 }

References pg_conn::cmd_queue_head, pg_conn::cmd_queue_tail, conn, PGcmdQueueEntry::next, and pqRecycleCmdQueueEntry().

Referenced by PQgetResult(), and pqParseInput3().

◆ PQconsumeInput()

int PQconsumeInput ( PGconn * conn )

Definition at line 1957 of file fe-exec.c.

 {
     if (!conn)
         return 0;
  
     /*
      * for non-blocking connections try to flush the send-queue, otherwise we
      * may never get a response for something that may not have already been
      * sent because it's in our write buffer!
      */
     if (pqIsnonblocking(conn))
     {
         if (pqFlush(conn) < 0)
             return 0;
     }
  
     /*
      * Load more data, if available. We do this no matter what state we are
      * in, since we are probably getting called because the application wants
      * to get rid of a read-select condition. Note that we will NOT block
      * waiting for more input.
      */
     if (pqReadData(conn) < 0)
         return 0;
  
     /* Parsing of the data waits till later. */
     return 1;
 }

References conn, pqFlush(), pqIsnonblocking, and pqReadData().

Referenced by advanceConnectionState(), CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), do_sql_command_end(), ecpg_process_output(), libpqrcv_PQgetResult(), libpqrcv_receive(), main(), pgfdw_cancel_query_end(), pgfdw_exec_cleanup_query_end(), pgfdw_get_cleanup_result(), pgfdw_get_result(), postgresForeignAsyncNotify(), PQconnectPoll(), PrintNotifications(), StreamLogicalLog(), test_nosync(), test_pipelined_insert(), test_uniqviol(), try_complete_step(), and wait_on_slots().

◆ PQcopyResult()

PGresult* PQcopyResult	(	const PGresult *	src,
		int	flags
	)

Definition at line 315 of file fe-exec.c.

 {
     PGresult   *dest;
     int         i;
  
     if (!src)
         return NULL;
  
     dest = PQmakeEmptyPGresult(NULL, PGRES_TUPLES_OK);
     if (!dest)
         return NULL;
  
     /* Always copy these over.  Is cmdStatus really useful here? */
     dest->client_encoding = src->client_encoding;
     strcpy(dest->cmdStatus, src->cmdStatus);
  
     /* Wants attrs? */
     if (flags & (PG_COPYRES_ATTRS | PG_COPYRES_TUPLES))
     {
         if (!PQsetResultAttrs(dest, src->numAttributes, src->attDescs))
         {
             PQclear(dest);
             return NULL;
         }
     }
  
     /* Wants to copy tuples? */
     if (flags & PG_COPYRES_TUPLES)
     {
         int         tup,
                     field;
  
         for (tup = 0; tup < src->ntups; tup++)
         {
             for (field = 0; field < src->numAttributes; field++)
             {
                 if (!PQsetvalue(dest, tup, field,
                                 src->tuples[tup][field].value,
                                 src->tuples[tup][field].len))
                 {
                     PQclear(dest);
                     return NULL;
                 }
             }
         }
     }
  
     /* Wants to copy notice hooks? */
     if (flags & PG_COPYRES_NOTICEHOOKS)
         dest->noticeHooks = src->noticeHooks;
  
     /* Wants to copy PGEvents? */
     if ((flags & PG_COPYRES_EVENTS) && src->nEvents > 0)
     {
         dest->events = dupEvents(src->events, src->nEvents,
                                  &dest->memorySize);
         if (!dest->events)
         {
             PQclear(dest);
             return NULL;
         }
         dest->nEvents = src->nEvents;
     }
  
     /* Okay, trigger PGEVT_RESULTCOPY event */
     for (i = 0; i < dest->nEvents; i++)
     {
         /* We don't fire events that had some previous failure */
         if (src->events[i].resultInitialized)
         {
             PGEventResultCopy evt;
  
             evt.src = src;
             evt.dest = dest;
             if (dest->events[i].proc(PGEVT_RESULTCOPY, &evt,
                                      dest->events[i].passThrough))
                 dest->events[i].resultInitialized = true;
         }
     }
  
     return dest;
 }

References pg_result::attDescs, pg_result::client_encoding, pg_result::cmdStatus, generate_unaccent_rules::dest, PGEventResultCopy::dest, dupEvents(), pg_result::events, i, pgresAttValue::len, pg_result::nEvents, pg_result::noticeHooks, pg_result::ntups, pg_result::numAttributes, PG_COPYRES_ATTRS, PG_COPYRES_EVENTS, PG_COPYRES_NOTICEHOOKS, PG_COPYRES_TUPLES, PGEVT_RESULTCOPY, PGRES_TUPLES_OK, PQclear(), PQmakeEmptyPGresult(), PQsetResultAttrs(), PQsetvalue(), PGEvent::resultInitialized, PGEventResultCopy::src, pg_result::tuples, and pgresAttValue::value.

Referenced by pqRowProcessor().

◆ PQdescribePortal()

PGresult* PQdescribePortal	(	PGconn *	conn,
		const char *	portal
	)

Definition at line 2440 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendTypedCommand(conn, PqMsg_Describe, 'P', portal))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), PqMsg_Describe, and PQsendTypedCommand().

Referenced by test_prepared().

◆ PQdescribePrepared()

PGresult* PQdescribePrepared	(	PGconn *	conn,
		const char *	stmt
	)

Definition at line 2421 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendTypedCommand(conn, PqMsg_Describe, 'S', stmt))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), PqMsg_Describe, PQsendTypedCommand(), and stmt.

Referenced by DescribeQuery(), ECPGdescribe(), and test_prepared().

◆ PQendcopy()

int PQendcopy ( PGconn * conn )

Definition at line 2915 of file fe-exec.c.

 {
     if (!conn)
         return 0;
  
     return pqEndcopy3(conn);
 }

References conn, and pqEndcopy3().

Referenced by ecpg_check_PQresult(), initPopulateTable(), and libpqrcv_endstreaming().

◆ PQenterPipelineMode()

int PQenterPipelineMode ( PGconn * conn )

Definition at line 3008 of file fe-exec.c.

 {
     if (!conn)
         return 0;
  
     /* succeed with no action if already in pipeline mode */
     if (conn->pipelineStatus != PQ_PIPELINE_OFF)
         return 1;
  
     if (conn->asyncStatus != PGASYNC_IDLE)
     {
         libpq_append_conn_error(conn, "cannot enter pipeline mode, connection not idle");
         return 0;
     }
  
     conn->pipelineStatus = PQ_PIPELINE_ON;
  
     return 1;
 }

References pg_conn::asyncStatus, conn, libpq_append_conn_error(), PGASYNC_IDLE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, and PQ_PIPELINE_ON.

Referenced by executeMetaCommand(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), and test_uniqviol().

◆ PQescapeBytea()

unsigned char* PQescapeBytea	(	const unsigned char *	from,
		size_t	from_length,
		size_t *	to_length
	)

Definition at line 4383 of file fe-exec.c.

 {
     return PQescapeByteaInternal(NULL, from, from_length, to_length,
                                  static_std_strings,
                                  false /* can't use hex */ );
 }

References PQescapeByteaInternal(), and static_std_strings.

◆ PQescapeByteaConn()

unsigned char* PQescapeByteaConn	(	PGconn *	conn,
		const unsigned char *	from,
		size_t	from_length,
		size_t *	to_length
	)

Definition at line 4367 of file fe-exec.c.

 {
     if (!conn)
         return NULL;
  
     if (conn->cmd_queue_head == NULL)
         pqClearConnErrorState(conn);
  
     return PQescapeByteaInternal(conn, from, from_length, to_length,
                                  conn->std_strings,
                                  (conn->sversion >= 90000));
 }

References pg_conn::cmd_queue_head, conn, pqClearConnErrorState, PQescapeByteaInternal(), pg_conn::std_strings, and pg_conn::sversion.

◆ PQescapeByteaInternal()

static unsigned char* PQescapeByteaInternal	(	PGconn *	conn,
		const unsigned char *	from,
		size_t	from_length,
		size_t *	to_length,
		bool	std_strings,
		bool	use_hex
	)

static

Definition at line 4271 of file fe-exec.c.

 {
     const unsigned char *vp;
     unsigned char *rp;
     unsigned char *result;
     size_t      i;
     size_t      len;
     size_t      bslash_len = (std_strings ? 1 : 2);
  
     /*
      * empty string has 1 char ('\0')
      */
     len = 1;
  
     if (use_hex)
     {
         len += bslash_len + 1 + 2 * from_length;
     }
     else
     {
         vp = from;
         for (i = from_length; i > 0; i--, vp++)
         {
             if (*vp < 0x20 || *vp > 0x7e)
                 len += bslash_len + 3;
             else if (*vp == '\'')
                 len += 2;
             else if (*vp == '\\')
                 len += bslash_len + bslash_len;
             else
                 len++;
         }
     }
  
     *to_length = len;
     rp = result = (unsigned char *) malloc(len);
     if (rp == NULL)
     {
         if (conn)
             libpq_append_conn_error(conn, "out of memory");
         return NULL;
     }
  
     if (use_hex)
     {
         if (!std_strings)
             *rp++ = '\\';
         *rp++ = '\\';
         *rp++ = 'x';
     }
  
     vp = from;
     for (i = from_length; i > 0; i--, vp++)
     {
         unsigned char c = *vp;
  
         if (use_hex)
         {
             *rp++ = hextbl[(c >> 4) & 0xF];
             *rp++ = hextbl[c & 0xF];
         }
         else if (c < 0x20 || c > 0x7e)
         {
             if (!std_strings)
                 *rp++ = '\\';
             *rp++ = '\\';
             *rp++ = (c >> 6) + '0';
             *rp++ = ((c >> 3) & 07) + '0';
             *rp++ = (c & 07) + '0';
         }
         else if (c == '\'')
         {
             *rp++ = '\'';
             *rp++ = '\'';
         }
         else if (c == '\\')
         {
             if (!std_strings)
             {
                 *rp++ = '\\';
                 *rp++ = '\\';
             }
             *rp++ = '\\';
             *rp++ = '\\';
         }
         else
             *rp++ = c;
     }
     *rp = '\0';
  
     return result;
 }

References conn, hextbl, i, len, libpq_append_conn_error(), and malloc.

Referenced by PQescapeBytea(), and PQescapeByteaConn().

◆ PQescapeIdentifier()

char* PQescapeIdentifier	(	PGconn *	conn,
		const char *	str,
		size_t	len
	)

Definition at line 4224 of file fe-exec.c.

 {
     return PQescapeInternal(conn, str, len, true);
 }

References conn, len, PQescapeInternal(), and generate_unaccent_rules::str.

Referenced by initCreatePKeys(), initCreateTables(), main(), psql_get_variable(), stringlist_to_identifierstr(), and vacuumlo().

◆ PQescapeInternal()

static char* PQescapeInternal	(	PGconn *	conn,
		const char *	str,
		size_t	len,
		bool	as_ident
	)

static

Definition at line 4096 of file fe-exec.c.

 {
     const char *s;
     char       *result;
     char       *rp;
     int         num_quotes = 0; /* single or double, depending on as_ident */
     int         num_backslashes = 0;
     int         input_len;
     int         result_size;
     char        quote_char = as_ident ? '"' : '\'';
  
     /* We must have a connection, else fail immediately. */
     if (!conn)
         return NULL;
  
     if (conn->cmd_queue_head == NULL)
         pqClearConnErrorState(conn);
  
     /* Scan the string for characters that must be escaped. */
     for (s = str; (s - str) < len && *s != '\0'; ++s)
     {
         if (*s == quote_char)
             ++num_quotes;
         else if (*s == '\\')
             ++num_backslashes;
         else if (IS_HIGHBIT_SET(*s))
         {
             int         charlen;
  
             /* Slow path for possible multibyte characters */
             charlen = pg_encoding_mblen(conn->client_encoding, s);
  
             /* Multibyte character overruns allowable length. */
             if ((s - str) + charlen > len || memchr(s, 0, charlen) != NULL)
             {
                 libpq_append_conn_error(conn, "incomplete multibyte character");
                 return NULL;
             }
  
             /* Adjust s, bearing in mind that for loop will increment it. */
             s += charlen - 1;
         }
     }
  
     /* Allocate output buffer. */
     input_len = s - str;
     result_size = input_len + num_quotes + 3;   /* two quotes, plus a NUL */
     if (!as_ident && num_backslashes > 0)
         result_size += num_backslashes + 2;
     result = rp = (char *) malloc(result_size);
     if (rp == NULL)
     {
         libpq_append_conn_error(conn, "out of memory");
         return NULL;
     }
  
     /*
      * If we are escaping a literal that contains backslashes, we use the
      * escape string syntax so that the result is correct under either value
      * of standard_conforming_strings.  We also emit a leading space in this
      * case, to guard against the possibility that the result might be
      * interpolated immediately following an identifier.
      */
     if (!as_ident && num_backslashes > 0)
     {
         *rp++ = ' ';
         *rp++ = 'E';
     }
  
     /* Opening quote. */
     *rp++ = quote_char;
  
     /*
      * Use fast path if possible.
      *
      * We've already verified that the input string is well-formed in the
      * current encoding.  If it contains no quotes and, in the case of
      * literal-escaping, no backslashes, then we can just copy it directly to
      * the output buffer, adding the necessary quotes.
      *
      * If not, we must rescan the input and process each character
      * individually.
      */
     if (num_quotes == 0 && (num_backslashes == 0 || as_ident))
     {
         memcpy(rp, str, input_len);
         rp += input_len;
     }
     else
     {
         for (s = str; s - str < input_len; ++s)
         {
             if (*s == quote_char || (!as_ident && *s == '\\'))
             {
                 *rp++ = *s;
                 *rp++ = *s;
             }
             else if (!IS_HIGHBIT_SET(*s))
                 *rp++ = *s;
             else
             {
                 int         i = pg_encoding_mblen(conn->client_encoding, s);
  
                 while (1)
                 {
                     *rp++ = *s;
                     if (--i == 0)
                         break;
                     ++s;        /* for loop will provide the final increment */
                 }
             }
         }
     }
  
     /* Closing quote and terminating NUL. */
     *rp++ = quote_char;
     *rp = '\0';
  
     return result;
 }

References pg_conn::client_encoding, pg_conn::cmd_queue_head, conn, i, IS_HIGHBIT_SET, len, libpq_append_conn_error(), malloc, pg_encoding_mblen(), pqClearConnErrorState, and generate_unaccent_rules::str.

Referenced by PQescapeIdentifier(), and PQescapeLiteral().

◆ PQescapeLiteral()

char* PQescapeLiteral	(	PGconn *	conn,
		const char *	str,
		size_t	len
	)

Definition at line 4218 of file fe-exec.c.

 {
     return PQescapeInternal(conn, str, len, false);
 }

References conn, len, PQescapeInternal(), and generate_unaccent_rules::str.

Referenced by DescribeQuery(), libpqrcv_startstreaming(), psql_get_variable(), and set_locale_and_encoding().

◆ PQescapeString()

size_t PQescapeString	(	char *	to,
		const char *	from,
		size_t	length
	)

Definition at line 4081 of file fe-exec.c.

 {
     return PQescapeStringInternal(NULL, to, from, length, NULL,
                                   static_client_encoding,
                                   static_std_strings);
 }

References PQescapeStringInternal(), static_client_encoding, and static_std_strings.

Referenced by get_comma_elts(), and quote_postgres().

◆ PQescapeStringConn()

size_t PQescapeStringConn	(	PGconn *	conn,
		char *	to,
		const char *	from,
		size_t	length,
		int *	error
	)

Definition at line 4059 of file fe-exec.c.

 {
     if (!conn)
     {
         /* force empty-string result */
         *to = '\0';
         if (error)
             *error = 1;
         return 0;
     }
  
     if (conn->cmd_queue_head == NULL)
         pqClearConnErrorState(conn);
  
     return PQescapeStringInternal(conn, to, from, length, error,
                                   conn->client_encoding,
                                   conn->std_strings);
 }

References pg_conn::client_encoding, pg_conn::cmd_queue_head, conn, error(), pqClearConnErrorState, PQescapeStringInternal(), and pg_conn::std_strings.

Referenced by AppendStringCommandOption(), appendStringLiteralConn(), check_loadable_libraries(), and do_lo_import().

◆ PQescapeStringInternal()

static size_t PQescapeStringInternal	(	PGconn *	conn,
		char *	to,
		const char *	from,
		size_t	length,
		int *	error,
		int	encoding,
		bool	std_strings
	)

static

Definition at line 3985 of file fe-exec.c.

 {
     const char *source = from;
     char       *target = to;
     size_t      remaining = length;
  
     if (error)
         *error = 0;
  
     while (remaining > 0 && *source != '\0')
     {
         char        c = *source;
         int         len;
         int         i;
  
         /* Fast path for plain ASCII */
         if (!IS_HIGHBIT_SET(c))
         {
             /* Apply quoting if needed */
             if (SQL_STR_DOUBLE(c, !std_strings))
                 *target++ = c;
             /* Copy the character */
             *target++ = c;
             source++;
             remaining--;
             continue;
         }
  
         /* Slow path for possible multibyte characters */
         len = pg_encoding_mblen(encoding, source);
  
         /* Copy the character */
         for (i = 0; i < len; i++)
         {
             if (remaining == 0 || *source == '\0')
                 break;
             *target++ = *source++;
             remaining--;
         }
  
         /*
          * If we hit premature end of string (ie, incomplete multibyte
          * character), try to pad out to the correct length with spaces. We
          * may not be able to pad completely, but we will always be able to
          * insert at least one pad space (since we'd not have quoted a
          * multibyte character).  This should be enough to make a string that
          * the server will error out on.
          */
         if (i < len)
         {
             if (error)
                 *error = 1;
             if (conn)
                 libpq_append_conn_error(conn, "incomplete multibyte character");
             for (; i < len; i++)
             {
                 if (((size_t) (target - to)) / 2 >= length)
                     break;
                 *target++ = ' ';
             }
             break;
         }
     }
  
     /* Write the terminating NUL character. */
     *target = '\0';
  
     return target - to;
 }

References conn, encoding, error(), i, IS_HIGHBIT_SET, len, libpq_append_conn_error(), pg_encoding_mblen(), remaining, source, and SQL_STR_DOUBLE.

Referenced by PQescapeString(), and PQescapeStringConn().

◆ PQexec()

PGresult* PQexec	(	PGconn *	conn,
		const char *	query
	)

Definition at line 2228 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendQuery(conn, query))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), and PQsendQuery().

Referenced by _doSetSessionAuth(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), check_loadable_libraries(), check_prepare_conn(), CreateReplicationSlot(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), deallocate_one(), DescribeQuery(), DropReplicationSlot(), ecpg_autostart_transaction(), ecpg_execute(), ECPGsetcommit(), ECPGtrans(), ExecQueryUsingCursor(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), get_create_object_cmd(), GetConnection(), GetSlotInformation(), GetTableInfo(), init_libpq_conn(), initPopulateTable(), libpq_traverse_files(), lo_initialize(), lockTableForWorker(), lookup_object_oid(), main(), pgfdw_xact_callback(), PQencryptPasswordConn(), PQsetClientEncoding(), PSQLexec(), ReceiveXlogStream(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), SendQuery(), sql_conn(), sql_exec(), StreamLogicalLog(), test_disallowed_in_pipeline(), test_pipeline_abort(), test_prepared(), test_transaction(), test_uniqviol(), tryExecuteStatement(), and vacuumlo().

◆ PQexecFinish()

static PGresult * PQexecFinish ( PGconn * conn )

static

Definition at line 2376 of file fe-exec.c.

 {
     PGresult   *result;
     PGresult   *lastResult;
  
     /*
      * For backwards compatibility, return the last result if there are more
      * than one.  (We used to have logic here to concatenate successive error
      * messages, but now that happens automatically, since conn->errorMessage
      * will continue to accumulate errors throughout this loop.)
      *
      * We have to stop if we see copy in/out/both, however. We will resume
      * parsing after application performs the data transfer.
      *
      * Also stop if the connection is lost (else we'll loop infinitely).
      */
     lastResult = NULL;
     while ((result = PQgetResult(conn)) != NULL)
     {
         PQclear(lastResult);
         lastResult = result;
         if (result->resultStatus == PGRES_COPY_IN ||
             result->resultStatus == PGRES_COPY_OUT ||
             result->resultStatus == PGRES_COPY_BOTH ||
             conn->status == CONNECTION_BAD)
             break;
     }
  
     return lastResult;
 }

References conn, CONNECTION_BAD, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PQclear(), PQgetResult(), pg_result::resultStatus, and pg_conn::status.

Referenced by PQclosePortal(), PQclosePrepared(), PQdescribePortal(), PQdescribePrepared(), PQexec(), PQexecParams(), PQexecPrepared(), and PQprepare().

◆ PQexecParams()

PGresult* PQexecParams	(	PGconn *	conn,
		const char *	command,
		int	nParams,
		const Oid *	paramTypes,
		const char const	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

Definition at line 2242 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendQueryParams(conn, command,
                            nParams, paramTypes, paramValues, paramLengths,
                            paramFormats, resultFormat))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), and PQsendQueryParams().

Referenced by ecpg_execute(), libpq_fetch_file(), and main().

◆ PQexecPrepared()

PGresult* PQexecPrepared	(	PGconn *	conn,
		const char *	stmtName,
		int	nParams,
		const char const	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

Definition at line 2289 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendQueryPrepared(conn, stmtName,
                              nParams, paramValues, paramLengths,
                              paramFormats, resultFormat))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), and PQsendQueryPrepared().

Referenced by ecpg_execute(), and try_complete_step().

◆ PQexecStart()

static bool PQexecStart ( PGconn * conn )

static

Definition at line 2310 of file fe-exec.c.

 {
     PGresult   *result;
  
     if (!conn)
         return false;
  
     /*
      * Since this is the beginning of a query cycle, reset the error state.
      * However, in pipeline mode with something already queued, the error
      * buffer belongs to that command and we shouldn't clear it.
      */
     if (conn->cmd_queue_head == NULL)
         pqClearConnErrorState(conn);
  
     if (conn->pipelineStatus != PQ_PIPELINE_OFF)
     {
         libpq_append_conn_error(conn, "synchronous command execution functions are not allowed in pipeline mode");
         return false;
     }
  
     /*
      * Silently discard any prior query result that application didn't eat.
      * This is probably poor design, but it's here for backward compatibility.
      */
     while ((result = PQgetResult(conn)) != NULL)
     {
         ExecStatusType resultStatus = result->resultStatus;
  
         PQclear(result);        /* only need its status */
         if (resultStatus == PGRES_COPY_IN)
         {
             /* get out of a COPY IN state */
             if (PQputCopyEnd(conn,
                              libpq_gettext("COPY terminated by new PQexec")) < 0)
                 return false;
             /* keep waiting to swallow the copy's failure message */
         }
         else if (resultStatus == PGRES_COPY_OUT)
         {
             /*
              * Get out of a COPY OUT state: we just switch back to BUSY and
              * allow the remaining COPY data to be dropped on the floor.
              */
             conn->asyncStatus = PGASYNC_BUSY;
             /* keep waiting to swallow the copy's completion message */
         }
         else if (resultStatus == PGRES_COPY_BOTH)
         {
             /* We don't allow PQexec during COPY BOTH */
             libpq_append_conn_error(conn, "PQexec not allowed during COPY BOTH");
             return false;
         }
         /* check for loss of connection, too */
         if (conn->status == CONNECTION_BAD)
             return false;
     }
  
     /* OK to send a command */
     return true;
 }

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, CONNECTION_BAD, libpq_append_conn_error(), libpq_gettext, PGASYNC_BUSY, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PQclear(), pqClearConnErrorState, PQgetResult(), PQputCopyEnd(), pg_result::resultStatus, and pg_conn::status.

Referenced by PQclosePortal(), PQclosePrepared(), PQdescribePortal(), PQdescribePrepared(), PQexec(), PQexecParams(), PQexecPrepared(), and PQprepare().

◆ PQexitPipelineMode()

int PQexitPipelineMode ( PGconn * conn )

Definition at line 3039 of file fe-exec.c.

 {
     if (!conn)
         return 0;
  
     if (conn->pipelineStatus == PQ_PIPELINE_OFF &&
         (conn->asyncStatus == PGASYNC_IDLE ||
          conn->asyncStatus == PGASYNC_PIPELINE_IDLE) &&
         conn->cmd_queue_head == NULL)
         return 1;
  
     switch (conn->asyncStatus)
     {
         case PGASYNC_READY:
         case PGASYNC_READY_MORE:
             /* there are some uncollected results */
             libpq_append_conn_error(conn, "cannot exit pipeline mode with uncollected results");
             return 0;
  
         case PGASYNC_BUSY:
             libpq_append_conn_error(conn, "cannot exit pipeline mode while busy");
             return 0;
  
         case PGASYNC_IDLE:
         case PGASYNC_PIPELINE_IDLE:
             /* OK */
             break;
  
         case PGASYNC_COPY_IN:
         case PGASYNC_COPY_OUT:
         case PGASYNC_COPY_BOTH:
             libpq_append_conn_error(conn, "cannot exit pipeline mode while in COPY");
     }
  
     /* still work to process */
     if (conn->cmd_queue_head != NULL)
     {
         libpq_append_conn_error(conn, "cannot exit pipeline mode with uncollected results");
         return 0;
     }
  
     conn->pipelineStatus = PQ_PIPELINE_OFF;
     conn->asyncStatus = PGASYNC_IDLE;
  
     /* Flush any pending data in out buffer */
     if (pqFlush(conn) < 0)
         return 0;               /* error message is setup already */
     return 1;
 }

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, libpq_append_conn_error(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, PGASYNC_READY, PGASYNC_READY_MORE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, and pqFlush().

Referenced by discardUntilSync(), readCommandResponse(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), and test_transaction().

◆ PQfformat()

int PQfformat	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3622 of file fe-exec.c.

 {
     if (!check_field_number(res, field_num))
         return 0;
     if (res->attDescs)
         return res->attDescs[field_num].format;
     else
         return 0;
 }

References pg_result::attDescs, check_field_number(), pgresAttDesc::format, and res.

Referenced by ecpg_get_data(), ecpg_store_result(), and process_queued_fetch_requests().

◆ PQflush()

int PQflush ( PGconn * conn )

Definition at line 3914 of file fe-exec.c.

 {
     if (!conn || conn->status == CONNECTION_BAD)
         return -1;
     return pqFlush(conn);
 }

References conn, CONNECTION_BAD, pqFlush(), and pg_conn::status.

Referenced by CheckCopyStreamStop(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), libpqrcv_send(), PQpipelineSync(), prepareToTerminate(), ProcessXLogDataMsg(), sendFeedback(), test_nosync(), test_pipelined_insert(), and test_uniqviol().

◆ PQfmod()

int PQfmod	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3655 of file fe-exec.c.

 {
     if (!check_field_number(res, field_num))
         return 0;
     if (res->attDescs)
         return res->attDescs[field_num].atttypmod;
     else
         return 0;
 }

References pg_result::attDescs, pgresAttDesc::atttypmod, check_field_number(), and res.

Referenced by DescribeQuery(), and ECPGget_desc().

◆ PQfn()

PGresult* PQfn	(	PGconn *	conn,
		int	fnid,
		int *	result_buf,
		int *	result_len,
		int	result_is_int,
		const PQArgBlock *	args,
		int	nargs
	)

Definition at line 2946 of file fe-exec.c.

 {
     *result_len = 0;
  
     if (!conn)
         return NULL;
  
     /*
      * Since this is the beginning of a query cycle, reset the error state.
      * However, in pipeline mode with something already queued, the error
      * buffer belongs to that command and we shouldn't clear it.
      */
     if (conn->cmd_queue_head == NULL)
         pqClearConnErrorState(conn);
  
     if (conn->pipelineStatus != PQ_PIPELINE_OFF)
     {
         libpq_append_conn_error(conn, "%s not allowed in pipeline mode", "PQfn");
         return NULL;
     }
  
     if (conn->sock == PGINVALID_SOCKET || conn->asyncStatus != PGASYNC_IDLE ||
         pgHavePendingResult(conn))
     {
         libpq_append_conn_error(conn, "connection in wrong state");
         return NULL;
     }
  
     return pqFunctionCall3(conn, fnid,
                            result_buf, result_len,
                            result_is_int,
                            args, nargs);
 }

References generate_unaccent_rules::args, pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, libpq_append_conn_error(), PGASYNC_IDLE, pgHavePendingResult, PGINVALID_SOCKET, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqClearConnErrorState, pqFunctionCall3(), and pg_conn::sock.

Referenced by lo_close(), lo_creat(), lo_create(), lo_lseek(), lo_lseek64(), lo_open(), lo_read(), lo_tell(), lo_tell64(), lo_truncate(), lo_truncate64(), lo_unlink(), and lo_write().

◆ PQfname()

char* PQfname	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3481 of file fe-exec.c.

 {
     if (!check_field_number(res, field_num))
         return NULL;
     if (res->attDescs)
         return res->attDescs[field_num].name;
     else
         return NULL;
 }

References pg_result::attDescs, check_field_number(), pgresAttDesc::name, and res.

Referenced by DescribeQuery(), do_header(), dumpTableData_insert(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ECPGget_desc(), indexOfColumn(), libpqrcv_processTuples(), main(), PQdisplayTuples(), PQprint(), PQprintTuples(), printCrosstab(), printQuery(), readCommandResponse(), sql_exec(), sqlda_compat_empty_size(), and StoreQueryTuple().

◆ PQfnumber()

int PQfnumber	(	const PGresult *	res,
		const char *	field_name
	)

Definition at line 3503 of file fe-exec.c.

 {
     char       *field_case;
     bool        in_quotes;
     bool        all_lower = true;
     const char *iptr;
     char       *optr;
     int         i;
  
     if (!res)
         return -1;
  
     /*
      * Note: it is correct to reject a zero-length input string; the proper
      * input to match a zero-length field name would be "".
      */
     if (field_name == NULL ||
         field_name[0] == '\0' ||
         res->attDescs == NULL)
         return -1;
  
     /*
      * Check if we can avoid the strdup() and related work because the
      * passed-in string wouldn't be changed before we do the check anyway.
      */
     for (iptr = field_name; *iptr; iptr++)
     {
         char        c = *iptr;
  
         if (c == '"' || c != pg_tolower((unsigned char) c))
         {
             all_lower = false;
             break;
         }
     }
  
     if (all_lower)
         for (i = 0; i < res->numAttributes; i++)
             if (strcmp(field_name, res->attDescs[i].name) == 0)
                 return i;
  
     /* Fall through to the normal check if that didn't work out. */
  
     /*
      * Note: this code will not reject partially quoted strings, eg
      * foo"BAR"foo will become fooBARfoo when it probably ought to be an error
      * condition.
      */
     field_case = strdup(field_name);
     if (field_case == NULL)
         return -1;              /* grotty */
  
     in_quotes = false;
     optr = field_case;
     for (iptr = field_case; *iptr; iptr++)
     {
         char        c = *iptr;
  
         if (in_quotes)
         {
             if (c == '"')
             {
                 if (iptr[1] == '"')
                 {
                     /* doubled quotes become a single quote */
                     *optr++ = '"';
                     iptr++;
                 }
                 else
                     in_quotes = false;
             }
             else
                 *optr++ = c;
         }
         else if (c == '"')
             in_quotes = true;
         else
         {
             c = pg_tolower((unsigned char) c);
             *optr++ = c;
         }
     }
     *optr = '\0';
  
     for (i = 0; i < res->numAttributes; i++)
     {
         if (strcmp(field_case, res->attDescs[i].name) == 0)
         {
             free(field_case);
             return i;
         }
     }
     free(field_case);
     return -1;
 }

References pg_result::attDescs, free, i, pgresAttDesc::name, pg_result::numAttributes, pg_tolower(), and res.

Referenced by append_depends_on_extension(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_tables_with_oids(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_proper_datallowconn(), collectComments(), collectSecLabels(), describeOneTableDetails(), dropRoles(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpFunc(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRoleMembership(), dumpRoles(), dumpTableSchema(), dumpTSConfig(), dumpUserMappings(), get_db_infos(), get_rel_infos(), get_tablespace_paths(), get_template0_info(), getAccessMethods(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRules(), getSubscriptions(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), old_9_6_invalidate_hash_indexes(), processExtensionTables(), report_extension_updates(), set_frozenxids(), and show_binary_results().

◆ PQfreemem()

void PQfreemem ( void * ptr )

Definition at line 3946 of file fe-exec.c.

 {
     free(ptr);
 }

References free.

Referenced by CopyStreamReceive(), dblink_get_notify(), DescribeQuery(), do_connect(), dumpTableData_copy(), ecpg_process_output(), exec_command_errverbose(), exec_command_password(), handleCopyOut(), HandleCopyStream(), HandleEndOfCopyStream(), initCreatePKeys(), initCreateTables(), libpqrcv_check_conninfo(), libpqrcv_disconnect(), libpqrcv_receive(), libpqrcv_startstreaming(), main(), PQfreeNotify(), PrintNotifications(), psql_get_variable(), ReceiveCopyData(), set_locale_and_encoding(), StreamLogicalLog(), stringlist_to_identifierstr(), try_complete_step(), and vacuumlo().

◆ PQfreeNotify()

void PQfreeNotify ( PGnotify * notify )

Definition at line 3963 of file fe-exec.c.

 {
     PQfreemem(notify);
 }

References PQfreemem().

◆ PQfsize()

int PQfsize	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3644 of file fe-exec.c.

 {
     if (!check_field_number(res, field_num))
         return 0;
     if (res->attDescs)
         return res->attDescs[field_num].typlen;
     else
         return 0;
 }

References pg_result::attDescs, check_field_number(), res, and pgresAttDesc::typlen.

Referenced by ecpg_build_compat_sqlda(), and ECPGget_desc().

◆ PQftable()

Oid PQftable	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3600 of file fe-exec.c.

 {
     if (!check_field_number(res, field_num))
         return InvalidOid;
     if (res->attDescs)
         return res->attDescs[field_num].tableid;
     else
         return InvalidOid;
 }

References pg_result::attDescs, check_field_number(), InvalidOid, res, and pgresAttDesc::tableid.

◆ PQftablecol()

int PQftablecol	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3611 of file fe-exec.c.

 {
     if (!check_field_number(res, field_num))
         return 0;
     if (res->attDescs)
         return res->attDescs[field_num].columnid;
     else
         return 0;
 }

References pg_result::attDescs, check_field_number(), pgresAttDesc::columnid, and res.

◆ PQftype()

Oid PQftype	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3633 of file fe-exec.c.

 {
     if (!check_field_number(res, field_num))
         return InvalidOid;
     if (res->attDescs)
         return res->attDescs[field_num].typid;
     else
         return InvalidOid;
 }

References pg_result::attDescs, check_field_number(), InvalidOid, res, and pgresAttDesc::typid.

Referenced by DescribeQuery(), dumpTableData_insert(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_store_result(), ECPGget_desc(), printCrosstab(), printQuery(), process_queued_fetch_requests(), sqlda_common_total_size(), and test_prepared().

◆ PQgetCopyData()

int PQgetCopyData	(	PGconn *	conn,
		char **	buffer,
		int	async
	)

Definition at line 2782 of file fe-exec.c.

 {
     *buffer = NULL;             /* for all failure cases */
     if (!conn)
         return -2;
     if (conn->asyncStatus != PGASYNC_COPY_OUT &&
         conn->asyncStatus != PGASYNC_COPY_BOTH)
     {
         libpq_append_conn_error(conn, "no COPY in progress");
         return -2;
     }
     return pqGetCopyData3(conn, buffer, async);
 }

References pg_conn::asyncStatus, conn, libpq_append_conn_error(), PGASYNC_COPY_BOTH, PGASYNC_COPY_OUT, and pqGetCopyData3().

Referenced by CopyStreamReceive(), dumpTableData_copy(), ecpg_process_output(), handleCopyOut(), libpqrcv_receive(), ReceiveCopyData(), and StreamLogicalLog().

◆ PQgetisnull()

int PQgetisnull	(	const PGresult *	res,
		int	tup_num,
		int	field_num
	)

Definition at line 3815 of file fe-exec.c.

 {
     if (!check_tuple_field_number(res, tup_num, field_num))
         return 1;               /* pretend it is null */
     if (res->tuples[tup_num][field_num].len == NULL_LEN)
         return 1;
     else
         return 0;
 }

References check_tuple_field_number(), pgresAttValue::len, NULL_LEN, res, and pg_result::tuples.

Referenced by addFooterToPublicationDesc(), BaseBackup(), compile_database_list(), compile_relation_list_one_db(), describeOneTableDetails(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpDatabase(), dumpDomain(), dumpFunc(), dumpRangeType(), dumpRoles(), dumpTableData_insert(), ecpg_get_data(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), ECPGget_desc(), ExecQueryTuples(), get_template0_info(), getAggregates(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getLOs(), getNamespaces(), getPolicies(), getProcLangs(), getPublicationTables(), GetSlotInformation(), getSubscriptions(), getTableAttrs(), GetTableInfo(), getTables(), getTriggers(), getTSDictionaries(), getTypes(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_create_slot(), libpqrcv_processTuples(), listTSConfigsVerbose(), listTSParsersVerbose(), make_tuple_from_result_row(), materializeResult(), postgresImportForeignSchema(), printCrosstab(), printQuery(), PrintResultInCrosstab(), process_queued_fetch_requests(), run_simple_query(), RunIdentifySystem(), sqlda_common_total_size(), StoreQueryTuple(), storeRow(), vacuum_one_database(), and verify_heap_slot_handler().

◆ PQgetlength()

int PQgetlength	(	const PGresult *	res,
		int	tup_num,
		int	field_num
	)

Definition at line 3801 of file fe-exec.c.

 {
     if (!check_tuple_field_number(res, tup_num, field_num))
         return 0;
     if (res->tuples[tup_num][field_num].len != NULL_LEN)
         return res->tuples[tup_num][field_num].len;
     else
         return 0;
 }

References check_tuple_field_number(), pgresAttValue::len, NULL_LEN, res, and pg_result::tuples.

Referenced by createViewAsClause(), do_field(), ecpg_get_data(), ecpg_store_result(), ECPGget_desc(), libpq_fetch_file(), libpqrcv_readtimelinehistoryfile(), PQdisplayTuples(), process_queued_fetch_requests(), and show_binary_results().

◆ PQgetline()

int PQgetline	(	PGconn *	conn,
		char *	buffer,
		int	length
	)

Definition at line 2820 of file fe-exec.c.

 {
     if (!buffer || length <= 0)
         return EOF;
     *buffer = '\0';
     /* length must be at least 3 to hold the \. terminator! */
     if (length < 3)
         return EOF;
  
     if (!conn)
         return EOF;
  
     return pqGetline3(conn, buffer, length);
 }

References conn, and pqGetline3().

◆ PQgetlineAsync()

int PQgetlineAsync	(	PGconn *	conn,
		char *	buffer,
		int	bufsize
	)

Definition at line 2867 of file fe-exec.c.

 {
     if (!conn)
         return -1;
  
     return pqGetlineAsync3(conn, buffer, bufsize);
 }

References bufsize, conn, and pqGetlineAsync3().

Referenced by pqGetline3().

◆ PQgetResult()

PGresult* PQgetResult ( PGconn * conn )

Definition at line 2035 of file fe-exec.c.

 {
     PGresult   *res;
  
     if (!conn)
         return NULL;
  
     /* Parse any available data, if our state permits. */
     parseInput(conn);
  
     /* If not ready to return something, block until we are. */
     while (conn->asyncStatus == PGASYNC_BUSY)
     {
         int         flushResult;
  
         /*
          * If data remains unsent, send it.  Else we might be waiting for the
          * result of a command the backend hasn't even got yet.
          */
         while ((flushResult = pqFlush(conn)) > 0)
         {
             if (pqWait(false, true, conn))
             {
                 flushResult = -1;
                 break;
             }
         }
  
         /*
          * Wait for some more data, and load it.  (Note: if the connection has
          * been lost, pqWait should return immediately because the socket
          * should be read-ready, either with the last server data or with an
          * EOF indication.  We expect therefore that this won't result in any
          * undue delay in reporting a previous write failure.)
          */
         if (flushResult ||
             pqWait(true, false, conn) ||
             pqReadData(conn) < 0)
         {
             /* Report the error saved by pqWait or pqReadData */
             pqSaveErrorResult(conn);
             conn->asyncStatus = PGASYNC_IDLE;
             return pqPrepareAsyncResult(conn);
         }
  
         /* Parse it. */
         parseInput(conn);
  
         /*
          * If we had a write error, but nothing above obtained a query result
          * or detected a read error, report the write error.
          */
         if (conn->write_failed && conn->asyncStatus == PGASYNC_BUSY)
         {
             pqSaveWriteError(conn);
             conn->asyncStatus = PGASYNC_IDLE;
             return pqPrepareAsyncResult(conn);
         }
     }
  
     /* Return the appropriate thing. */
     switch (conn->asyncStatus)
     {
         case PGASYNC_IDLE:
             res = NULL;         /* query is complete */
             break;
         case PGASYNC_PIPELINE_IDLE:
             Assert(conn->pipelineStatus != PQ_PIPELINE_OFF);
  
             /*
              * We're about to return the NULL that terminates the round of
              * results from the current query; prepare to send the results of
              * the next query, if any, when we're called next.  If there's no
              * next element in the command queue, this gets us in IDLE state.
              */
             pqPipelineProcessQueue(conn);
             res = NULL;         /* query is complete */
             break;
  
         case PGASYNC_READY:
  
             /*
              * For any query type other than simple query protocol, we advance
              * the command queue here.  This is because for simple query
              * protocol we can get the READY state multiple times before the
              * command is actually complete, since the command string can
              * contain many queries.  In simple query protocol, the queue
              * advance is done by fe-protocol3 when it receives ReadyForQuery.
              */
             if (conn->cmd_queue_head &&
                 conn->cmd_queue_head->queryclass != PGQUERY_SIMPLE)
                 pqCommandQueueAdvance(conn);
             res = pqPrepareAsyncResult(conn);
             if (conn->pipelineStatus != PQ_PIPELINE_OFF)
             {
                 /*
                  * We're about to send the results of the current query.  Set
                  * us idle now, and ...
                  */
                 conn->asyncStatus = PGASYNC_PIPELINE_IDLE;
  
                 /*
                  * ... in cases when we're sending a pipeline-sync result,
                  * move queue processing forwards immediately, so that next
                  * time we're called, we're prepared to return the next result
                  * received from the server.  In all other cases, leave the
                  * queue state change for next time, so that a terminating
                  * NULL result is sent.
                  *
                  * (In other words: we don't return a NULL after a pipeline
                  * sync.)
                  */
                 if (res && res->resultStatus == PGRES_PIPELINE_SYNC)
                     pqPipelineProcessQueue(conn);
             }
             else
             {
                 /* Set the state back to BUSY, allowing parsing to proceed. */
                 conn->asyncStatus = PGASYNC_BUSY;
             }
             break;
         case PGASYNC_READY_MORE:
             res = pqPrepareAsyncResult(conn);
             /* Set the state back to BUSY, allowing parsing to proceed. */
             conn->asyncStatus = PGASYNC_BUSY;
             break;
         case PGASYNC_COPY_IN:
             res = getCopyResult(conn, PGRES_COPY_IN);
             break;
         case PGASYNC_COPY_OUT:
             res = getCopyResult(conn, PGRES_COPY_OUT);
             break;
         case PGASYNC_COPY_BOTH:
             res = getCopyResult(conn, PGRES_COPY_BOTH);
             break;
         default:
             libpq_append_conn_error(conn, "unexpected asyncStatus: %d", (int) conn->asyncStatus);
             pqSaveErrorResult(conn);
             conn->asyncStatus = PGASYNC_IDLE;   /* try to restore valid state */
             res = pqPrepareAsyncResult(conn);
             break;
     }
  
     /* Time to fire PGEVT_RESULTCREATE events, if there are any */
     if (res && res->nEvents > 0)
         (void) PQfireResultCreateEvents(conn, res);
  
     return res;
 }

References Assert(), pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, getCopyResult(), libpq_append_conn_error(), pg_result::nEvents, parseInput(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, PGASYNC_READY, PGASYNC_READY_MORE, PGQUERY_SIMPLE, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_PIPELINE_SYNC, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqCommandQueueAdvance(), PQfireResultCreateEvents(), pqFlush(), pqPipelineProcessQueue(), pqPrepareAsyncResult(), pqReadData(), pqSaveErrorResult(), pqSaveWriteError(), pqWait(), PGcmdQueueEntry::queryclass, res, pg_result::resultStatus, and pg_conn::write_failed.

Referenced by advanceConnectionState(), BaseBackup(), ClearOrSaveAllResults(), consumeQueryResult(), dblink_record_internal(), discardUntilSync(), dumpTableData_copy(), ecpg_process_output(), EndDBCopyMode(), ExecQueryAndProcessResults(), handleCopyIn(), handleCopyOut(), HandleEndOfCopyStream(), libpqrcv_PQgetResult(), pgfdw_finish_pre_commit_cleanup(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PQconnectPoll(), pqEndcopy3(), PQexecFinish(), PQexecStart(), process_queued_fetch_requests(), process_result(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), storeQueryResult(), StreamLogicalLog(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), test_uniqviol(), try_complete_step(), and wait_on_slots().

◆ PQgetvalue()

char* PQgetvalue	(	const PGresult *	res,
		int	tup_num,
		int	field_num
	)

Definition at line 3790 of file fe-exec.c.

 {
     if (!check_tuple_field_number(res, tup_num, field_num))
         return NULL;
     return res->tuples[tup_num][field_num].value;
 }

References check_tuple_field_number(), res, pg_result::tuples, and pgresAttValue::value.

Referenced by _check_database_version(), add_tablespace_footer(), addFooterToPublicationDesc(), append_depends_on_extension(), appendQualifiedRelation(), BaseBackup(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_tables_with_oids(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_is_install_user(), check_proper_datallowconn(), cluster_all_databases(), collectComments(), collectRoleNames(), collectSecLabels(), compile_database_list(), compile_relation_list_one_db(), convertTSFunction(), createViewAsClause(), describeOneTableDetails(), describePublications(), describeRoles(), describeTableDetails(), do_field(), dropDBs(), dropRoles(), dropTablespaces(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpDomain(), dumpEnumType(), dumpForeignServer(), dumpFunc(), dumpLOs(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRoleGUCPrivs(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSearchPath(), dumpSequence(), dumpSequenceData(), dumpStatisticsExt(), dumpTable(), dumpTableAttach(), dumpTableData_insert(), dumpTableSchema(), dumpTablespaces(), dumpTSConfig(), dumpTSDictionary(), dumpUserConfig(), dumpUserMappings(), ecpg_get_data(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), ecpg_store_result(), emitShSecLabels(), exec_command_password(), ExecQueryTuples(), expand_dbname_patterns(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), get_create_object_cmd(), get_db_infos(), get_language_name(), get_loadable_libraries(), get_next_possible_free_pg_type_oid(), get_parallel_object_list(), get_rel_infos(), get_remote_estimate(), get_synchronized_snapshot(), get_tablespace_paths(), get_template0_info(), getAccessMethods(), getAdditionalACLs(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFormattedTypeName(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPartitioningInfo(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRules(), GetSlotInformation(), getSubscriptions(), getTableAttrs(), GetTableInfo(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_identify_system(), libpqrcv_processTuples(), libpqrcv_readtimelinehistoryfile(), listExtensionContents(), listSchemas(), listTSConfigsVerbose(), listTSParsersVerbose(), lo_initialize(), lookup_object_oid(), main(), make_tuple_from_result_row(), materializeResult(), old_9_6_invalidate_hash_indexes(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), PQconnectPoll(), PQdisplayTuples(), PQencryptPasswordConn(), PQprintTuples(), printCrosstab(), printQuery(), PrintResultInCrosstab(), process_queued_fetch_requests(), process_result(), processExtensionTables(), readCommandResponse(), ReadEndOfStreamingResult(), ReceiveXlogStream(), reindex_all_databases(), report_extension_updates(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_simple_query(), RunIdentifySystem(), set_frozenxids(), show_binary_results(), sql_exec(), sqlda_common_total_size(), StoreQueryTuple(), storeRow(), test_pipeline_abort(), test_singlerowmode(), test_transaction(), try_complete_step(), vacuum_all_databases(), vacuum_one_database(), vacuumlo(), and verify_heap_slot_handler().

◆ pqInternalNotice()

void pqInternalNotice	(	const PGNoticeHooks *	hooks,
		const char *	fmt,
			...
	)

Definition at line 933 of file fe-exec.c.

 {
     char        msgBuf[1024];
     va_list     args;
     PGresult   *res;
  
     if (hooks->noticeRec == NULL)
         return;                 /* nobody home to receive notice? */
  
     /* Format the message */
     va_start(args, fmt);
     vsnprintf(msgBuf, sizeof(msgBuf), libpq_gettext(fmt), args);
     va_end(args);
     msgBuf[sizeof(msgBuf) - 1] = '\0';  /* make real sure it's terminated */
  
     /* Make a PGresult to pass to the notice receiver */
     res = PQmakeEmptyPGresult(NULL, PGRES_NONFATAL_ERROR);
     if (!res)
         return;
     res->noticeHooks = *hooks;
  
     /*
      * Set up fields of notice.
      */
     pqSaveMessageField(res, PG_DIAG_MESSAGE_PRIMARY, msgBuf);
     pqSaveMessageField(res, PG_DIAG_SEVERITY, libpq_gettext("NOTICE"));
     pqSaveMessageField(res, PG_DIAG_SEVERITY_NONLOCALIZED, "NOTICE");
     /* XXX should provide a SQLSTATE too? */
  
     /*
      * Result text is always just the primary message + newline.  If we can't
      * allocate it, substitute "out of memory", as in pqSetResultError.
      */
     res->errMsg = (char *) pqResultAlloc(res, strlen(msgBuf) + 2, false);
     if (res->errMsg)
         sprintf(res->errMsg, "%s\n", msgBuf);
     else
         res->errMsg = libpq_gettext("out of memory\n");
  
     /*
      * Pass to receiver, then free it.
      */
     res->noticeHooks.noticeRec(res->noticeHooks.noticeRecArg, res);
     PQclear(res);
 }

References generate_unaccent_rules::args, pg_result::errMsg, fmt, libpq_gettext, pg_result::noticeHooks, PGNoticeHooks::noticeRec, PGNoticeHooks::noticeRecArg, PG_DIAG_MESSAGE_PRIMARY, PG_DIAG_SEVERITY, PG_DIAG_SEVERITY_NONLOCALIZED, PGRES_NONFATAL_ERROR, PQclear(), PQmakeEmptyPGresult(), pqResultAlloc(), pqSaveMessageField(), res, sprintf, va_end(), va_start(), and vsnprintf.

Referenced by check_field_number(), check_param_number(), check_tuple_field_number(), PQcmdTuples(), pqEndcopy3(), pqGetInt(), pqParseInput3(), pqPutInt(), and PQsetvalue().

◆ PQisBusy()

int PQisBusy ( PGconn * conn )

Definition at line 2004 of file fe-exec.c.

 {
     if (!conn)
         return false;
  
     /* Parse any available data, if our state permits. */
     parseInput(conn);
  
     /*
      * PQgetResult will return immediately in all states except BUSY.  Also,
      * if we've detected read EOF and dropped the connection, we can expect
      * that PQgetResult will fail immediately.  Note that we do *not* check
      * conn->write_failed here --- once that's become set, we know we have
      * trouble, but we need to keep trying to read until we have a complete
      * server message or detect read EOF.
      */
     return conn->asyncStatus == PGASYNC_BUSY && conn->status != CONNECTION_BAD;
 }

References pg_conn::asyncStatus, conn, CONNECTION_BAD, parseInput(), PGASYNC_BUSY, and pg_conn::status.

Referenced by advanceConnectionState(), dblink_is_busy(), libpqrcv_PQgetResult(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PQconnectPoll(), pqEndcopy3(), test_disallowed_in_pipeline(), test_pipelined_insert(), test_uniqviol(), try_complete_step(), and wait_on_slots().

◆ PQisnonblocking()

int PQisnonblocking ( const PGconn * conn )

Definition at line 3897 of file fe-exec.c.

 {
     if (!conn || conn->status == CONNECTION_BAD)
         return false;
     return pqIsnonblocking(conn);
 }

References conn, CONNECTION_BAD, pqIsnonblocking, and pg_conn::status.

Referenced by test_disallowed_in_pipeline(), and test_simple_pipeline().

◆ PQisthreadsafe()

int PQisthreadsafe ( void )

Definition at line 3906 of file fe-exec.c.

 {
     return true;
 }

◆ PQmakeEmptyPGresult()

PGresult* PQmakeEmptyPGresult	(	PGconn *	conn,
		ExecStatusType	status
	)

Definition at line 157 of file fe-exec.c.

 {
     PGresult   *result;
  
     result = (PGresult *) malloc(sizeof(PGresult));
     if (!result)
         return NULL;
  
     result->ntups = 0;
     result->numAttributes = 0;
     result->attDescs = NULL;
     result->tuples = NULL;
     result->tupArrSize = 0;
     result->numParameters = 0;
     result->paramDescs = NULL;
     result->resultStatus = status;
     result->cmdStatus[0] = '\0';
     result->binary = 0;
     result->events = NULL;
     result->nEvents = 0;
     result->errMsg = NULL;
     result->errFields = NULL;
     result->errQuery = NULL;
     result->null_field[0] = '\0';
     result->curBlock = NULL;
     result->curOffset = 0;
     result->spaceLeft = 0;
     result->memorySize = sizeof(PGresult);
  
     if (conn)
     {
         /* copy connection data we might need for operations on PGresult */
         result->noticeHooks = conn->noticeHooks;
         result->client_encoding = conn->client_encoding;
  
         /* consider copying conn's errorMessage */
         switch (status)
         {
             case PGRES_EMPTY_QUERY:
             case PGRES_COMMAND_OK:
             case PGRES_TUPLES_OK:
             case PGRES_COPY_OUT:
             case PGRES_COPY_IN:
             case PGRES_COPY_BOTH:
             case PGRES_SINGLE_TUPLE:
                 /* non-error cases */
                 break;
             default:
                 /* we intentionally do not use or modify errorReported here */
                 pqSetResultError(result, &conn->errorMessage, 0);
                 break;
         }
  
         /* copy events last; result must be valid if we need to PQclear */
         if (conn->nEvents > 0)
         {
             result->events = dupEvents(conn->events, conn->nEvents,
                                        &result->memorySize);
             if (!result->events)
             {
                 PQclear(result);
                 return NULL;
             }
             result->nEvents = conn->nEvents;
         }
     }
     else
     {
         /* defaults... */
         result->noticeHooks.noticeRec = NULL;
         result->noticeHooks.noticeRecArg = NULL;
         result->noticeHooks.noticeProc = NULL;
         result->noticeHooks.noticeProcArg = NULL;
         result->client_encoding = PG_SQL_ASCII;
     }
  
     return result;
 }

References pg_result::attDescs, pg_result::binary, pg_result::client_encoding, pg_conn::client_encoding, pg_result::cmdStatus, conn, pg_result::curBlock, pg_result::curOffset, dupEvents(), pg_result::errFields, pg_result::errMsg, pg_conn::errorMessage, pg_result::errQuery, pg_result::events, pg_conn::events, malloc, pg_result::memorySize, pg_result::nEvents, pg_conn::nEvents, pg_result::noticeHooks, pg_conn::noticeHooks, PGNoticeHooks::noticeProc, PGNoticeHooks::noticeProcArg, PGNoticeHooks::noticeRec, PGNoticeHooks::noticeRecArg, pg_result::ntups, pg_result::null_field, pg_result::numAttributes, pg_result::numParameters, pg_result::paramDescs, PG_SQL_ASCII, PGRES_COMMAND_OK, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_EMPTY_QUERY, PGRES_SINGLE_TUPLE, PGRES_TUPLES_OK, PQclear(), pqSetResultError(), pg_result::resultStatus, pg_result::spaceLeft, pg_result::tupArrSize, and pg_result::tuples.

Referenced by ECPGallocate_desc(), getCopyResult(), getCopyStart(), getParamDescriptions(), getRowDescriptions(), PQcopyResult(), pqFunctionCall3(), pqGetErrorNotice3(), pqInternalNotice(), pqParseInput3(), pqPipelineProcessQueue(), and pqPrepareAsyncResult().

◆ PQnfields()

int PQnfields ( const PGresult * res )

Definition at line 3403 of file fe-exec.c.

 {
     if (!res)
         return 0;
     return res->numAttributes;
 }

References pg_result::numAttributes, and res.

Referenced by BaseBackup(), CreateReplicationSlot(), DescribeQuery(), DropReplicationSlot(), dumpTableData_insert(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_process_output(), ECPGget_desc(), ECPGget_desc_header(), ExecQueryTuples(), GetSlotInformation(), indexOfColumn(), libpq_traverse_files(), libpqrcv_endstreaming(), libpqrcv_identify_system(), libpqrcv_processTuples(), libpqrcv_readtimelinehistoryfile(), main(), make_tuple_from_result_row(), materializeResult(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), PQdisplayTuples(), PQencryptPasswordConn(), PQprint(), PQprintTuples(), printQuery(), PrintResultInCrosstab(), process_queued_fetch_requests(), readCommandResponse(), ReadEndOfStreamingResult(), ReceiveXlogStream(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_simple_query(), RunIdentifySystem(), sql_exec(), sqlda_common_total_size(), sqlda_compat_empty_size(), sqlda_native_empty_size(), StoreQueryTuple(), storeRow(), and test_prepared().

◆ PQnotifies()

PGnotify* PQnotifies ( PGconn * conn )

Definition at line 2633 of file fe-exec.c.

 {
     PGnotify   *event;
  
     if (!conn)
         return NULL;
  
     /* Parse any available data to see if we can extract NOTIFY messages. */
     parseInput(conn);
  
     event = conn->notifyHead;
     if (event)
     {
         conn->notifyHead = event->next;
         if (!conn->notifyHead)
             conn->notifyTail = NULL;
         event->next = NULL;     /* don't let app see the internal state */
     }
     return event;
 }

References conn, pgNotify::next, pg_conn::notifyHead, pg_conn::notifyTail, and parseInput().

Referenced by dblink_get_notify(), ecpg_process_output(), main(), PrintNotifications(), and try_complete_step().

◆ PQnparams()

int PQnparams ( const PGresult * res )

Definition at line 3829 of file fe-exec.c.

 {
     if (!res)
         return 0;
     return res->numParameters;
 }

References pg_result::numParameters, and res.

◆ PQntuples()

int PQntuples ( const PGresult * res )

Definition at line 3395 of file fe-exec.c.

 {
     if (!res)
         return 0;
     return res->ntups;
 }

References pg_result::ntups, and res.

Referenced by add_tablespace_footer(), addFooterToPublicationDesc(), append_depends_on_extension(), appendQualifiedRelation(), BaseBackup(), buildMatViewRefreshDependencies(), check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_tables_with_oids(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_is_install_user(), check_proper_datallowconn(), cluster_all_databases(), collectComments(), collectRoleNames(), collectSecLabels(), compile_database_list(), compile_relation_list_one_db(), CreateReplicationSlot(), createViewAsClause(), describeOneTableDetails(), describePublications(), describeRoles(), describeTableDetails(), dropDBs(), DropReplicationSlot(), dropRoles(), dropTablespaces(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpEnumType(), dumpLOs(), dumpOpclass(), dumpOpfamily(), dumpRoleGUCPrivs(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSequence(), dumpSequenceData(), dumpTable(), dumpTableData_insert(), dumpTablespaces(), dumpTSConfig(), dumpUserConfig(), dumpUserMappings(), ecpg_process_output(), ecpg_store_result(), ECPGget_desc(), emitShSecLabels(), ExecQueryAndProcessResults(), ExecQueryTuples(), ExecQueryUsingCursor(), execute_dml_stmt(), execute_foreign_modify(), ExecuteSqlQueryForSingleRow(), expand_dbname_patterns(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), fetch_more_data(), get_create_object_cmd(), get_db_infos(), get_loadable_libraries(), get_parallel_object_list(), get_rel_infos(), get_tablespace_paths(), get_template0_info(), getAccessMethods(), getAdditionalACLs(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPartitioningInfo(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRules(), GetSlotInformation(), getSubscriptions(), getTableAttrs(), GetTableInfo(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_endstreaming(), libpqrcv_identify_system(), libpqrcv_processTuples(), libpqrcv_readtimelinehistoryfile(), listDbRoleSettings(), listExtensionContents(), listSchemas(), listTables(), listTSConfigsVerbose(), listTSParsersVerbose(), lo_initialize(), lookup_object_oid(), main(), make_tuple_from_result_row(), materializeResult(), old_9_6_invalidate_hash_indexes(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), PQconnectPoll(), PQdisplayTuples(), PQencryptPasswordConn(), PQprint(), PQprintTuples(), printCrosstab(), printQuery(), PrintResultInCrosstab(), process_queued_fetch_requests(), processExtensionTables(), readCommandResponse(), ReadEndOfStreamingResult(), ReceiveXlogStream(), reindex_all_databases(), report_extension_updates(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_simple_query(), RunIdentifySystem(), set_frozenxids(), show_binary_results(), sql_exec(), StoreQueryTuple(), storeRow(), test_pipeline_abort(), test_singlerowmode(), test_transaction(), try_complete_step(), vacuum_all_databases(), vacuum_one_database(), vacuumlo(), verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ PQoidStatus()

char* PQoidStatus ( const PGresult * res )

Definition at line 3679 of file fe-exec.c.

 {
     /*
      * This must be enough to hold the result. Don't laugh, this is better
      * than what this function used to do.
      */
     static char buf[24];
  
     size_t      len;
  
     if (!res || strncmp(res->cmdStatus, "INSERT ", 7) != 0)
         return "";
  
     len = strspn(res->cmdStatus + 7, "0123456789");
     if (len > sizeof(buf) - 1)
         len = sizeof(buf) - 1;
     memcpy(buf, res->cmdStatus + 7, len);
     buf[len] = '\0';
  
     return buf;
 }

References buf, pg_result::cmdStatus, len, and res.

◆ PQoidValue()

Oid PQoidValue ( const PGresult * res )

Definition at line 3707 of file fe-exec.c.

 {
     char       *endptr = NULL;
     unsigned long result;
  
     if (!res ||
         strncmp(res->cmdStatus, "INSERT ", 7) != 0 ||
         res->cmdStatus[7] < '0' ||
         res->cmdStatus[7] > '9')
         return InvalidOid;
  
     result = strtoul(res->cmdStatus + 7, &endptr, 10);
  
     if (!endptr || (*endptr != ' ' && *endptr != '\0'))
         return InvalidOid;
     else
         return (Oid) result;
 }

References pg_result::cmdStatus, InvalidOid, and res.

Referenced by ecpg_process_output(), and PrintQueryStatus().

◆ PQparamtype()

Oid PQparamtype	(	const PGresult *	res,
		int	param_num
	)

Definition at line 3840 of file fe-exec.c.

 {
     if (!check_param_number(res, param_num))
         return InvalidOid;
     if (res->paramDescs)
         return res->paramDescs[param_num].typid;
     else
         return InvalidOid;
 }

References check_param_number(), InvalidOid, pg_result::paramDescs, res, and pgresParamDesc::typid.

◆ pqPipelineFlush()

static int pqPipelineFlush ( PGconn * conn )

static

Definition at line 3930 of file fe-exec.c.

 {
     if ((conn->pipelineStatus != PQ_PIPELINE_ON) ||
         (conn->outCount >= OUTBUFFER_THRESHOLD))
         return pqFlush(conn);
     return 0;
 }

References conn, OUTBUFFER_THRESHOLD, pg_conn::outCount, pg_conn::pipelineStatus, PQ_PIPELINE_ON, and pqFlush().

Referenced by PQsendPrepare(), PQsendQueryGuts(), and PQsendTypedCommand().

◆ pqPipelineProcessQueue()

static void pqPipelineProcessQueue ( PGconn * conn )

static

Definition at line 3120 of file fe-exec.c.

 {
     switch (conn->asyncStatus)
     {
         case PGASYNC_COPY_IN:
         case PGASYNC_COPY_OUT:
         case PGASYNC_COPY_BOTH:
         case PGASYNC_READY:
         case PGASYNC_READY_MORE:
         case PGASYNC_BUSY:
             /* client still has to process current query or results */
             return;
  
         case PGASYNC_IDLE:
  
             /*
              * If we're in IDLE mode and there's some command in the queue,
              * get us into PIPELINE_IDLE mode and process normally.  Otherwise
              * there's nothing for us to do.
              */
             if (conn->cmd_queue_head != NULL)
             {
                 conn->asyncStatus = PGASYNC_PIPELINE_IDLE;
                 break;
             }
             return;
  
         case PGASYNC_PIPELINE_IDLE:
             Assert(conn->pipelineStatus != PQ_PIPELINE_OFF);
             /* next query please */
             break;
     }
  
     /*
      * Reset single-row processing mode.  (Client has to set it up for each
      * query, if desired.)
      */
     conn->singleRowMode = false;
  
     /*
      * If there are no further commands to process in the queue, get us in
      * "real idle" mode now.
      */
     if (conn->cmd_queue_head == NULL)
     {
         conn->asyncStatus = PGASYNC_IDLE;
         return;
     }
  
     /*
      * Reset the error state.  This and the next couple of steps correspond to
      * what PQsendQueryStart didn't do for this query.
      */
     pqClearConnErrorState(conn);
  
     /* Initialize async result-accumulation state */
     pqClearAsyncResult(conn);
  
     if (conn->pipelineStatus == PQ_PIPELINE_ABORTED &&
         conn->cmd_queue_head->queryclass != PGQUERY_SYNC)
     {
         /*
          * In an aborted pipeline we don't get anything from the server for
          * each result; we're just discarding commands from the queue until we
          * get to the next sync from the server.
          *
          * The PGRES_PIPELINE_ABORTED results tell the client that its queries
          * got aborted.
          */
         conn->result = PQmakeEmptyPGresult(conn, PGRES_PIPELINE_ABORTED);
         if (!conn->result)
         {
             libpq_append_conn_error(conn, "out of memory");
             pqSaveErrorResult(conn);
             return;
         }
         conn->asyncStatus = PGASYNC_READY;
     }
     else
     {
         /* allow parsing to continue */
         conn->asyncStatus = PGASYNC_BUSY;
     }
 }

References Assert(), pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, libpq_append_conn_error(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, PGASYNC_READY, PGASYNC_READY_MORE, PGQUERY_SYNC, PGRES_PIPELINE_ABORTED, pg_conn::pipelineStatus, PQ_PIPELINE_ABORTED, PQ_PIPELINE_OFF, pqClearAsyncResult(), pqClearConnErrorState, PQmakeEmptyPGresult(), pqSaveErrorResult(), PGcmdQueueEntry::queryclass, pg_conn::result, and pg_conn::singleRowMode.

Referenced by pqAppendCmdQueueEntry(), and PQgetResult().

◆ PQpipelineSync()

int PQpipelineSync ( PGconn * conn )

Definition at line 3226 of file fe-exec.c.

 {
     PGcmdQueueEntry *entry;
  
     if (!conn)
         return 0;
  
     if (conn->pipelineStatus == PQ_PIPELINE_OFF)
     {
         libpq_append_conn_error(conn, "cannot send pipeline when not in pipeline mode");
         return 0;
     }
  
     switch (conn->asyncStatus)
     {
         case PGASYNC_COPY_IN:
         case PGASYNC_COPY_OUT:
         case PGASYNC_COPY_BOTH:
             /* should be unreachable */
             appendPQExpBufferStr(&conn->errorMessage,
                                  "internal error: cannot send pipeline while in COPY\n");
             return 0;
         case PGASYNC_READY:
         case PGASYNC_READY_MORE:
         case PGASYNC_BUSY:
         case PGASYNC_IDLE:
         case PGASYNC_PIPELINE_IDLE:
             /* OK to send sync */
             break;
     }
  
     entry = pqAllocCmdQueueEntry(conn);
     if (entry == NULL)
         return 0;               /* error msg already set */
  
     entry->queryclass = PGQUERY_SYNC;
     entry->query = NULL;
  
     /* construct the Sync message */
     if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
         pqPutMsgEnd(conn) < 0)
         goto sendFailed;
  
     /*
      * Give the data a push.  In nonblock mode, don't complain if we're unable
      * to send it all; PQgetResult() will do any additional flushing needed.
      */
     if (PQflush(conn) < 0)
         goto sendFailed;
  
     /* OK, it's launched! */
     pqAppendCmdQueueEntry(conn, entry);
  
     return 1;
  
 sendFailed:
     pqRecycleCmdQueueEntry(conn, entry);
     /* error message should be set up already */
     return 0;
 }

References appendPQExpBufferStr(), pg_conn::asyncStatus, conn, pg_conn::errorMessage, libpq_append_conn_error(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, PGASYNC_READY, PGASYNC_READY_MORE, PGQUERY_SYNC, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqAllocCmdQueueEntry(), pqAppendCmdQueueEntry(), PQflush(), PqMsg_Sync, pqPutMsgEnd(), pqPutMsgStart(), pqRecycleCmdQueueEntry(), PGcmdQueueEntry::query, and PGcmdQueueEntry::queryclass.

Referenced by discardUntilSync(), executeMetaCommand(), test_multi_pipelines(), test_pipeline_abort(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), and test_transaction().

◆ PQprepare()

PGresult* PQprepare	(	PGconn *	conn,
		const char *	stmtName,
		const char *	query,
		int	nParams,
		const Oid *	paramTypes
	)

Definition at line 2272 of file fe-exec.c.

 {
     if (!PQexecStart(conn))
         return NULL;
     if (!PQsendPrepare(conn, stmtName, query, nParams, paramTypes))
         return NULL;
     return PQexecFinish(conn);
 }

References conn, PQexecFinish(), PQexecStart(), and PQsendPrepare().

Referenced by DescribeQuery(), init_libpq_conn(), main(), prepare_common(), prepareCommand(), and test_uniqviol().

◆ pqPrepareAsyncResult()

PGresult* pqPrepareAsyncResult ( PGconn * conn )

Definition at line 846 of file fe-exec.c.

 {
     PGresult   *res;
  
     res = conn->result;
     if (res)
     {
         /*
          * If the pre-existing result is an ERROR (presumably something
          * received from the server), assume that it represents whatever is in
          * conn->errorMessage, and advance errorReported.
          */
         if (res->resultStatus == PGRES_FATAL_ERROR)
             conn->errorReported = conn->errorMessage.len;
     }
     else
     {
         /*
          * We get here after internal-to-libpq errors.  We should probably
          * always have error_result = true, but if we don't, gin up some error
          * text.
          */
         if (!conn->error_result)
             libpq_append_conn_error(conn, "no error text available");
  
         /* Paranoia: be sure errorReported offset is sane */
         if (conn->errorReported < 0 ||
             conn->errorReported >= conn->errorMessage.len)
             conn->errorReported = 0;
  
         /*
          * Make a PGresult struct for the error.  We temporarily lie about the
          * result status, so that PQmakeEmptyPGresult doesn't uselessly copy
          * all of conn->errorMessage.
          */
         res = PQmakeEmptyPGresult(conn, PGRES_EMPTY_QUERY);
         if (res)
         {
             /*
              * Report whatever new error text we have, and advance
              * errorReported.
              */
             res->resultStatus = PGRES_FATAL_ERROR;
             pqSetResultError(res, &conn->errorMessage, conn->errorReported);
             conn->errorReported = conn->errorMessage.len;
         }
         else
         {
             /*
              * Ouch, not enough memory for a PGresult.  Fortunately, we have a
              * card up our sleeve: we can use the static OOM_result.  Casting
              * away const here is a bit ugly, but it seems best to declare
              * OOM_result as const, in hopes it will be allocated in read-only
              * storage.
              */
             res = unconstify(PGresult *, &OOM_result);
  
             /*
              * Don't advance errorReported.  Perhaps we'll be able to report
              * the text later.
              */
         }
     }
  
     /*
      * Replace conn->result with next_result, if any.  In the normal case
      * there isn't a next result and we're just dropping ownership of the
      * current result.  In single-row mode this restores the situation to what
      * it was before we created the current single-row result.
      */
     conn->result = conn->next_result;
     conn->error_result = false; /* next_result is never an error */
     conn->next_result = NULL;
  
     return res;
 }

References conn, pg_conn::error_result, pg_conn::errorMessage, pg_conn::errorReported, PQExpBufferData::len, libpq_append_conn_error(), pg_conn::next_result, OOM_result, PGRES_EMPTY_QUERY, PGRES_FATAL_ERROR, PQmakeEmptyPGresult(), pqSetResultError(), res, pg_conn::result, pg_result::resultStatus, and unconstify.

Referenced by getCopyResult(), pqFunctionCall3(), and PQgetResult().

◆ PQputCopyData()

int PQputCopyData	(	PGconn *	conn,
		const char *	buffer,
		int	nbytes
	)

Definition at line 2661 of file fe-exec.c.

 {
     if (!conn)
         return -1;
     if (conn->asyncStatus != PGASYNC_COPY_IN &&
         conn->asyncStatus != PGASYNC_COPY_BOTH)
     {
         libpq_append_conn_error(conn, "no COPY in progress");
         return -1;
     }
  
     /*
      * Process any NOTICE or NOTIFY messages that might be pending in the
      * input buffer.  Since the server might generate many notices during the
      * COPY, we want to clean those out reasonably promptly to prevent
      * indefinite expansion of the input buffer.  (Note: the actual read of
      * input data into the input buffer happens down inside pqSendSome, but
      * it's not authorized to get rid of the data again.)
      */
     parseInput(conn);
  
     if (nbytes > 0)
     {
         /*
          * Try to flush any previously sent data in preference to growing the
          * output buffer.  If we can't enlarge the buffer enough to hold the
          * data, return 0 in the nonblock case, else hard error. (For
          * simplicity, always assume 5 bytes of overhead.)
          */
         if ((conn->outBufSize - conn->outCount - 5) < nbytes)
         {
             if (pqFlush(conn) < 0)
                 return -1;
             if (pqCheckOutBufferSpace(conn->outCount + 5 + (size_t) nbytes,
                                       conn))
                 return pqIsnonblocking(conn) ? 0 : -1;
         }
         /* Send the data (too simple to delegate to fe-protocol files) */
         if (pqPutMsgStart(PqMsg_CopyData, conn) < 0 ||
             pqPutnchar(buffer, nbytes, conn) < 0 ||
             pqPutMsgEnd(conn) < 0)
             return -1;
     }
     return 1;
 }

References pg_conn::asyncStatus, conn, libpq_append_conn_error(), pg_conn::outBufSize, pg_conn::outCount, parseInput(), PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, pqCheckOutBufferSpace(), pqFlush(), pqIsnonblocking, PqMsg_CopyData, pqPutMsgEnd(), pqPutMsgStart(), and pqPutnchar().

Referenced by ExecuteSqlCommandBuf(), handleCopyIn(), libpqrcv_send(), PQputnbytes(), and sendFeedback().

◆ PQputCopyEnd()

int PQputCopyEnd	(	PGconn *	conn,
		const char *	errormsg
	)

Definition at line 2715 of file fe-exec.c.

 {
     if (!conn)
         return -1;
     if (conn->asyncStatus != PGASYNC_COPY_IN &&
         conn->asyncStatus != PGASYNC_COPY_BOTH)
     {
         libpq_append_conn_error(conn, "no COPY in progress");
         return -1;
     }
  
     /*
      * Send the COPY END indicator.  This is simple enough that we don't
      * bother delegating it to the fe-protocol files.
      */
     if (errormsg)
     {
         /* Send COPY FAIL */
         if (pqPutMsgStart(PqMsg_CopyFail, conn) < 0 ||
             pqPuts(errormsg, conn) < 0 ||
             pqPutMsgEnd(conn) < 0)
             return -1;
     }
     else
     {
         /* Send COPY DONE */
         if (pqPutMsgStart(PqMsg_CopyDone, conn) < 0 ||
             pqPutMsgEnd(conn) < 0)
             return -1;
     }
  
     /*
      * If we sent the COPY command in extended-query mode, we must issue a
      * Sync as well.
      */
     if (conn->cmd_queue_head &&
         conn->cmd_queue_head->queryclass != PGQUERY_SIMPLE)
     {
         if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
             pqPutMsgEnd(conn) < 0)
             return -1;
     }
  
     /* Return to active duty */
     if (conn->asyncStatus == PGASYNC_COPY_BOTH)
         conn->asyncStatus = PGASYNC_COPY_OUT;
     else
         conn->asyncStatus = PGASYNC_BUSY;
  
     /* Try to flush data */
     if (pqFlush(conn) < 0)
         return -1;
  
     return 1;
 }

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, libpq_append_conn_error(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGQUERY_SIMPLE, pqFlush(), PqMsg_CopyDone, PqMsg_CopyFail, PqMsg_Sync, pqPutMsgEnd(), pqPutMsgStart(), pqPuts(), and PGcmdQueueEntry::queryclass.

Referenced by CheckCopyStreamStop(), EndDBCopyMode(), handleCopyIn(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), PQexecStart(), prepareToTerminate(), and ProcessXLogDataMsg().

◆ PQputline()

int PQputline	(	PGconn *	conn,
		const char *	string
	)

Definition at line 2884 of file fe-exec.c.

 {
     return PQputnbytes(conn, string, strlen(string));
 }

References conn, and PQputnbytes().

Referenced by initPopulateTable().

◆ PQputnbytes()

int PQputnbytes	(	PGconn *	conn,
		const char *	buffer,
		int	nbytes
	)

Definition at line 2894 of file fe-exec.c.

 {
     if (PQputCopyData(conn, buffer, nbytes) > 0)
         return 0;
     else
         return EOF;
 }

References conn, and PQputCopyData().

Referenced by PQputline().

◆ pqRecycleCmdQueueEntry()

static void pqRecycleCmdQueueEntry	(	PGconn *	conn,
		PGcmdQueueEntry *	entry
	)

static

Definition at line 1392 of file fe-exec.c.

 {
     if (entry == NULL)
         return;
  
     /* recyclable entries should not have a follow-on command */
     Assert(entry->next == NULL);
  
     if (entry->query)
     {
         free(entry->query);
         entry->query = NULL;
     }
  
     entry->next = conn->cmd_queue_recycle;
     conn->cmd_queue_recycle = entry;
 }

References Assert(), pg_conn::cmd_queue_recycle, conn, free, PGcmdQueueEntry::next, and PGcmdQueueEntry::query.

Referenced by pqCommandQueueAdvance(), PQpipelineSync(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and PQsendTypedCommand().

◆ PQresStatus()

char* PQresStatus ( ExecStatusType status )

Definition at line 3333 of file fe-exec.c.

 {
     if ((unsigned int) status >= lengthof(pgresStatus))
         return libpq_gettext("invalid ExecStatusType code");
     return pgresStatus[status];
 }

References lengthof, libpq_gettext, and pgresStatus.

Referenced by process_result(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), and try_complete_step().

◆ PQresultAlloc()

void* PQresultAlloc	(	PGresult *	res,
		size_t	nBytes
	)

Definition at line 540 of file fe-exec.c.

 {
     /* Fail if argument is NULL or OOM_result */
     if (!res || (const PGresult *) res == &OOM_result)
         return NULL;
  
     return pqResultAlloc(res, nBytes, true);
 }

References OOM_result, pqResultAlloc(), and res.

Referenced by PQsetResultAttrs().

◆ pqResultAlloc()

void* pqResultAlloc	(	PGresult *	res,
		size_t	nBytes,
		bool	isBinary
	)

Definition at line 560 of file fe-exec.c.

 {
     char       *space;
     PGresult_data *block;
  
     if (!res)
         return NULL;
  
     if (nBytes <= 0)
         return res->null_field;
  
     /*
      * If alignment is needed, round up the current position to an alignment
      * boundary.
      */
     if (isBinary)
     {
         int         offset = res->curOffset % PGRESULT_ALIGN_BOUNDARY;
  
         if (offset)
         {
             res->curOffset += PGRESULT_ALIGN_BOUNDARY - offset;
             res->spaceLeft -= PGRESULT_ALIGN_BOUNDARY - offset;
         }
     }
  
     /* If there's enough space in the current block, no problem. */
     if (nBytes <= (size_t) res->spaceLeft)
     {
         space = res->curBlock->space + res->curOffset;
         res->curOffset += nBytes;
         res->spaceLeft -= nBytes;
         return space;
     }
  
     /*
      * If the requested object is very large, give it its own block; this
      * avoids wasting what might be most of the current block to start a new
      * block.  (We'd have to special-case requests bigger than the block size
      * anyway.)  The object is always given binary alignment in this case.
      */
     if (nBytes >= PGRESULT_SEP_ALLOC_THRESHOLD)
     {
         size_t      alloc_size = nBytes + PGRESULT_BLOCK_OVERHEAD;
  
         block = (PGresult_data *) malloc(alloc_size);
         if (!block)
             return NULL;
         res->memorySize += alloc_size;
         space = block->space + PGRESULT_BLOCK_OVERHEAD;
         if (res->curBlock)
         {
             /*
              * Tuck special block below the active block, so that we don't
              * have to waste the free space in the active block.
              */
             block->next = res->curBlock->next;
             res->curBlock->next = block;
         }
         else
         {
             /* Must set up the new block as the first active block. */
             block->next = NULL;
             res->curBlock = block;
             res->spaceLeft = 0; /* be sure it's marked full */
         }
         return space;
     }
  
     /* Otherwise, start a new block. */
     block = (PGresult_data *) malloc(PGRESULT_DATA_BLOCKSIZE);
     if (!block)
         return NULL;
     res->memorySize += PGRESULT_DATA_BLOCKSIZE;
     block->next = res->curBlock;
     res->curBlock = block;
     if (isBinary)
     {
         /* object needs full alignment */
         res->curOffset = PGRESULT_BLOCK_OVERHEAD;
         res->spaceLeft = PGRESULT_DATA_BLOCKSIZE - PGRESULT_BLOCK_OVERHEAD;
     }
     else
     {
         /* we can cram it right after the overhead pointer */
         res->curOffset = sizeof(PGresult_data);
         res->spaceLeft = PGRESULT_DATA_BLOCKSIZE - sizeof(PGresult_data);
     }
  
     space = block->space + res->curOffset;
     res->curOffset += nBytes;
     res->spaceLeft -= nBytes;
     return space;
 }

References pg_result::curBlock, pg_result::curOffset, malloc, pg_result::memorySize, pgresult_data::next, pg_result::null_field, PGRESULT_ALIGN_BOUNDARY, PGRESULT_BLOCK_OVERHEAD, PGRESULT_DATA_BLOCKSIZE, PGRESULT_SEP_ALLOC_THRESHOLD, res, pgresult_data::space, and pg_result::spaceLeft.

Referenced by getCopyStart(), getParamDescriptions(), getRowDescriptions(), pqInternalNotice(), PQresultAlloc(), pqResultStrdup(), pqRowProcessor(), pqSaveMessageField(), and PQsetvalue().

◆ PQresultErrorField()

char* PQresultErrorField	(	const PGresult *	res,
		int	fieldcode
	)

Definition at line 3380 of file fe-exec.c.

 {
     PGMessageField *pfield;
  
     if (!res)
         return NULL;
     for (pfield = res->errFields; pfield != NULL; pfield = pfield->next)
     {
         if (pfield->code == fieldcode)
             return pfield->contents;
     }
     return NULL;
 }

References pgMessageField::code, pgMessageField::contents, pg_result::errFields, pgMessageField::next, and res.

Referenced by BaseBackup(), CreateReplicationSlot(), dblink_res_error(), ecpg_raise_backend(), ECPGnoticeReceiver(), GetTableInfo(), libpqrcv_exec(), minimal_error_message(), pgfdw_report_error(), pgpassfileWarning(), pqBuildErrorMessage3(), PQconnectPoll(), readCommandResponse(), SetResultVariables(), should_processing_continue(), TableCommandResultHandler(), test_pipeline_abort(), and try_complete_step().

◆ PQresultErrorMessage()

char* PQresultErrorMessage ( const PGresult * res )

Definition at line 3341 of file fe-exec.c.

 {
     if (!res || !res->errMsg)
         return "";
     return res->errMsg;
 }

References pg_result::errMsg, and res.

Referenced by defaultNoticeReceiver(), ecpg_check_PQresult(), ecpg_process_output(), ExecQueryAndProcessResults(), init_libpq_conn(), libpq_fetch_file(), libpq_traverse_files(), process_queued_fetch_requests(), ReceiveXlogStream(), run_simple_command(), run_simple_query(), StreamLogicalLog(), test_pipeline_abort(), and try_complete_step().

◆ PQresultMemorySize()

size_t PQresultMemorySize ( const PGresult * res )

Definition at line 660 of file fe-exec.c.

 {
     if (!res)
         return 0;
     return res->memorySize;
 }

References pg_result::memorySize, and res.

◆ PQresultStatus()

ExecStatusType PQresultStatus ( const PGresult * res )

Definition at line 3325 of file fe-exec.c.

 {
     if (!res)
         return PGRES_FATAL_ERROR;
     return res->resultStatus;
 }

References PGRES_FATAL_ERROR, res, and pg_result::resultStatus.

Referenced by _doSetSessionAuth(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), AcceptResult(), advanceConnectionState(), BaseBackup(), check_loadable_libraries(), check_prepare_conn(), ClearOrSaveResult(), close_cursor(), compile_database_list(), compile_relation_list_one_db(), create_cursor(), CreateReplicationSlot(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), dblink_record_internal(), deallocate_query(), DescribeQuery(), discardUntilSync(), do_sql_command_end(), DropReplicationSlot(), dumpTableData_copy(), ecpg_check_PQresult(), ecpg_process_output(), EndDBCopyMode(), ExecQueryAndProcessResults(), ExecQueryUsingCursor(), execute_dml_stmt(), execute_foreign_modify(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), fetch_more_data(), get_create_object_cmd(), get_remote_estimate(), GetConnection(), GetSlotInformation(), GetTableInfo(), handleCopyIn(), handleCopyOut(), HandleCopyResult(), HandleEndOfCopyStream(), init_libpq_conn(), initPopulateTable(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_PQexec(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_startstreaming(), lo_close(), lo_creat(), lo_create(), lo_lseek(), lo_lseek64(), lo_open(), lo_read(), lo_tell(), lo_tell64(), lo_truncate(), lo_truncate64(), lo_unlink(), lo_write(), lockTableForWorker(), lookup_object_oid(), main(), materializeResult(), pgfdw_exec_cleanup_query_end(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), postgresReScanForeignScan(), PQconnectPoll(), PQencryptPasswordConn(), prepare_foreign_modify(), prepareCommand(), PrintQueryResult(), PrintResultInCrosstab(), process_queued_fetch_requests(), process_result(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), SendQuery(), should_processing_continue(), sql_conn(), sql_exec(), storeQueryResult(), StreamLogicalLog(), TableCommandResultHandler(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), test_uniqviol(), try_complete_step(), tryExecuteStatement(), vacuumlo(), verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ pqResultStrdup()

char* pqResultStrdup	(	PGresult *	res,
		const char *	str
	)

Definition at line 672 of file fe-exec.c.

 {
     char       *space = (char *) pqResultAlloc(res, strlen(str) + 1, false);
  
     if (space)
         strcpy(space, str);
     return space;
 }

References pqResultAlloc(), res, and generate_unaccent_rules::str.

Referenced by getRowDescriptions(), pqGetErrorNotice3(), PQsetResultAttrs(), and pqSetResultError().

◆ PQresultVerboseErrorMessage()

char* PQresultVerboseErrorMessage	(	const PGresult *	res,
		PGVerbosity	verbosity,
		PGContextVisibility	show_context
	)

Definition at line 3349 of file fe-exec.c.

 {
     PQExpBufferData workBuf;
  
     /*
      * Because the caller is expected to free the result string, we must
      * strdup any constant result.  We use plain strdup and document that
      * callers should expect NULL if out-of-memory.
      */
     if (!res ||
         (res->resultStatus != PGRES_FATAL_ERROR &&
          res->resultStatus != PGRES_NONFATAL_ERROR))
         return strdup(libpq_gettext("PGresult is not an error result\n"));
  
     initPQExpBuffer(&workBuf);
  
     pqBuildErrorMessage3(&workBuf, res, verbosity, show_context);
  
     /* If insufficient memory to format the message, fail cleanly */
     if (PQExpBufferDataBroken(workBuf))
     {
         termPQExpBuffer(&workBuf);
         return strdup(libpq_gettext("out of memory\n"));
     }
  
     return workBuf.data;
 }

References PQExpBufferData::data, initPQExpBuffer(), libpq_gettext, PGRES_FATAL_ERROR, PGRES_NONFATAL_ERROR, pqBuildErrorMessage3(), PQExpBufferDataBroken, res, pg_result::resultStatus, and termPQExpBuffer().

Referenced by exec_command_errverbose().

◆ pqRowProcessor()

int pqRowProcessor	(	PGconn *	conn,
		const char **	errmsgp
	)

Definition at line 1206 of file fe-exec.c.

 {
     PGresult   *res = conn->result;
     int         nfields = res->numAttributes;
     const PGdataValue *columns = conn->rowBuf;
     PGresAttValue *tup;
     int         i;
  
     /*
      * In single-row mode, make a new PGresult that will hold just this one
      * row; the original conn->result is left unchanged so that it can be used
      * again as the template for future rows.
      */
     if (conn->singleRowMode)
     {
         /* Copy everything that should be in the result at this point */
         res = PQcopyResult(res,
                            PG_COPYRES_ATTRS | PG_COPYRES_EVENTS |
                            PG_COPYRES_NOTICEHOOKS);
         if (!res)
             return 0;
     }
  
     /*
      * Basically we just allocate space in the PGresult for each field and
      * copy the data over.
      *
      * Note: on malloc failure, we return 0 leaving *errmsgp still NULL, which
      * caller will take to mean "out of memory".  This is preferable to trying
      * to set up such a message here, because evidently there's not enough
      * memory for gettext() to do anything.
      */
     tup = (PGresAttValue *)
         pqResultAlloc(res, nfields * sizeof(PGresAttValue), true);
     if (tup == NULL)
         goto fail;
  
     for (i = 0; i < nfields; i++)
     {
         int         clen = columns[i].len;
  
         if (clen < 0)
         {
             /* null field */
             tup[i].len = NULL_LEN;
             tup[i].value = res->null_field;
         }
         else
         {
             bool        isbinary = (res->attDescs[i].format != 0);
             char       *val;
  
             val = (char *) pqResultAlloc(res, clen + 1, isbinary);
             if (val == NULL)
                 goto fail;
  
             /* copy and zero-terminate the data (even if it's binary) */
             memcpy(val, columns[i].value, clen);
             val[clen] = '\0';
  
             tup[i].len = clen;
             tup[i].value = val;
         }
     }
  
     /* And add the tuple to the PGresult's tuple array */
     if (!pqAddTuple(res, tup, errmsgp))
         goto fail;
  
     /*
      * Success.  In single-row mode, make the result available to the client
      * immediately.
      */
     if (conn->singleRowMode)
     {
         /* Change result status to special single-row value */
         res->resultStatus = PGRES_SINGLE_TUPLE;
         /* Stash old result for re-use later */
         conn->next_result = conn->result;
         conn->result = res;
         /* And mark the result ready to return */
         conn->asyncStatus = PGASYNC_READY_MORE;
     }
  
     return 1;
  
 fail:
     /* release locally allocated PGresult, if we made one */
     if (res != conn->result)
         PQclear(res);
     return 0;
 }

References pg_conn::asyncStatus, pg_result::attDescs, conn, pgresAttDesc::format, i, pgresAttValue::len, pgDataValue::len, pg_conn::next_result, pg_result::null_field, NULL_LEN, pg_result::numAttributes, PG_COPYRES_ATTRS, PG_COPYRES_EVENTS, PG_COPYRES_NOTICEHOOKS, PGASYNC_READY_MORE, PGRES_SINGLE_TUPLE, pqAddTuple(), PQclear(), PQcopyResult(), pqResultAlloc(), res, pg_conn::result, pg_result::resultStatus, pg_conn::rowBuf, pg_conn::singleRowMode, val, value, and pgresAttValue::value.

Referenced by getAnotherTuple().

◆ pqSaveErrorResult()

void pqSaveErrorResult ( PGconn * conn )

Definition at line 800 of file fe-exec.c.

 {
     /* Drop any pending result ... */
     pqClearAsyncResult(conn);
     /* ... and set flag to remember to make an error result later */
     conn->error_result = true;
 }

References conn, pg_conn::error_result, and pqClearAsyncResult().

Referenced by getAnotherTuple(), getCopyResult(), getParamDescriptions(), getRowDescriptions(), handleSyncLoss(), pqFunctionCall3(), PQgetResult(), pqParseInput3(), pqPipelineProcessQueue(), and pqSaveWriteError().

◆ pqSaveMessageField()

void pqSaveMessageField	(	PGresult *	res,
		char	code,
		const char *	value
	)

Definition at line 1055 of file fe-exec.c.

 {
     PGMessageField *pfield;
  
     pfield = (PGMessageField *)
         pqResultAlloc(res,
                       offsetof(PGMessageField, contents) +
                       strlen(value) + 1,
                       true);
     if (!pfield)
         return;                 /* out of memory? */
     pfield->code = code;
     strcpy(pfield->contents, value);
     pfield->next = res->errFields;
     res->errFields = pfield;
 }

References pgMessageField::code, pgMessageField::contents, pg_result::errFields, pgMessageField::next, pqResultAlloc(), res, and value.

Referenced by pqGetErrorNotice3(), and pqInternalNotice().

◆ pqSaveParameterStatus()

void pqSaveParameterStatus	(	PGconn *	conn,
		const char *	name,
		const char *	value
	)

Definition at line 1076 of file fe-exec.c.

 {
     pgParameterStatus *pstatus;
     pgParameterStatus *prev;
  
     /*
      * Forget any old information about the parameter
      */
     for (pstatus = conn->pstatus, prev = NULL;
          pstatus != NULL;
          prev = pstatus, pstatus = pstatus->next)
     {
         if (strcmp(pstatus->name, name) == 0)
         {
             if (prev)
                 prev->next = pstatus->next;
             else
                 conn->pstatus = pstatus->next;
             free(pstatus);      /* frees name and value strings too */
             break;
         }
     }
  
     /*
      * Store new info as a single malloc block
      */
     pstatus = (pgParameterStatus *) malloc(sizeof(pgParameterStatus) +
                                            strlen(name) + strlen(value) + 2);
     if (pstatus)
     {
         char       *ptr;
  
         ptr = ((char *) pstatus) + sizeof(pgParameterStatus);
         pstatus->name = ptr;
         strcpy(ptr, name);
         ptr += strlen(name) + 1;
         pstatus->value = ptr;
         strcpy(ptr, value);
         pstatus->next = conn->pstatus;
         conn->pstatus = pstatus;
     }
  
     /*
      * Save values of settings that are of interest to libpq in fields of the
      * PGconn object.  We keep client_encoding and standard_conforming_strings
      * in static variables as well, so that PQescapeString and PQescapeBytea
      * can behave somewhat sanely (at least in single-connection-using
      * programs).
      */
     if (strcmp(name, "client_encoding") == 0)
     {
         conn->client_encoding = pg_char_to_encoding(value);
         /* if we don't recognize the encoding name, fall back to SQL_ASCII */
         if (conn->client_encoding < 0)
             conn->client_encoding = PG_SQL_ASCII;
         static_client_encoding = conn->client_encoding;
     }
     else if (strcmp(name, "standard_conforming_strings") == 0)
     {
         conn->std_strings = (strcmp(value, "on") == 0);
         static_std_strings = conn->std_strings;
     }
     else if (strcmp(name, "server_version") == 0)
     {
         /* We convert the server version to numeric form. */
         int         cnt;
         int         vmaj,
                     vmin,
                     vrev;
  
         cnt = sscanf(value, "%d.%d.%d", &vmaj, &vmin, &vrev);
  
         if (cnt == 3)
         {
             /* old style, e.g. 9.6.1 */
             conn->sversion = (100 * vmaj + vmin) * 100 + vrev;
         }
         else if (cnt == 2)
         {
             if (vmaj >= 10)
             {
                 /* new style, e.g. 10.1 */
                 conn->sversion = 100 * 100 * vmaj + vmin;
             }
             else
             {
                 /* old style without minor version, e.g. 9.6devel */
                 conn->sversion = (100 * vmaj + vmin) * 100;
             }
         }
         else if (cnt == 1)
         {
             /* new style without minor version, e.g. 10devel */
             conn->sversion = 100 * 100 * vmaj;
         }
         else
             conn->sversion = 0; /* unknown */
     }
     else if (strcmp(name, "default_transaction_read_only") == 0)
     {
         conn->default_transaction_read_only =
             (strcmp(value, "on") == 0) ? PG_BOOL_YES : PG_BOOL_NO;
     }
     else if (strcmp(name, "in_hot_standby") == 0)
     {
         conn->in_hot_standby =
             (strcmp(value, "on") == 0) ? PG_BOOL_YES : PG_BOOL_NO;
     }
     else if (strcmp(name, "scram_iterations") == 0)
     {
         conn->scram_sha_256_iterations = atoi(value);
     }
 }

References pg_conn::client_encoding, conn, pg_conn::default_transaction_read_only, free, pg_conn::in_hot_standby, malloc, name, pgParameterStatus::name, pgParameterStatus::next, PG_BOOL_NO, PG_BOOL_YES, pg_char_to_encoding(), PG_SQL_ASCII, pg_conn::pstatus, pg_conn::scram_sha_256_iterations, static_client_encoding, static_std_strings, pg_conn::std_strings, pg_conn::sversion, value, and pgParameterStatus::value.

Referenced by getParameterStatus().

◆ pqSaveWriteError()

static void pqSaveWriteError ( PGconn * conn )

static

Definition at line 817 of file fe-exec.c.

 {
     /*
      * If write_err_msg is null because of previous strdup failure, do what we
      * can.  (It's likely our machinations here will get OOM failures as well,
      * but might as well try.)
      */
     if (conn->write_err_msg)
     {
         appendPQExpBufferStr(&conn->errorMessage, conn->write_err_msg);
         /* Avoid possibly appending the same message twice */
         conn->write_err_msg[0] = '\0';
     }
     else
         libpq_append_conn_error(conn, "write to server failed");
  
     pqSaveErrorResult(conn);
 }

References appendPQExpBufferStr(), conn, pg_conn::errorMessage, libpq_append_conn_error(), pqSaveErrorResult(), and pg_conn::write_err_msg.

Referenced by PQgetResult().

◆ PQsendClosePortal()

int PQsendClosePortal	(	PGconn *	conn,
		const char *	portal
	)

Definition at line 2535 of file fe-exec.c.

 {
     return PQsendTypedCommand(conn, PqMsg_Close, 'P', portal);
 }

References conn, PqMsg_Close, and PQsendTypedCommand().

Referenced by test_prepared().

◆ PQsendClosePrepared()

int PQsendClosePrepared	(	PGconn *	conn,
		const char *	stmt
	)

Definition at line 2522 of file fe-exec.c.

 {
     return PQsendTypedCommand(conn, PqMsg_Close, 'S', stmt);
 }

References conn, PqMsg_Close, PQsendTypedCommand(), and stmt.

Referenced by test_prepared().

◆ PQsendDescribePortal()

int PQsendDescribePortal	(	PGconn *	conn,
		const char *	portal
	)

Definition at line 2470 of file fe-exec.c.

 {
     return PQsendTypedCommand(conn, PqMsg_Describe, 'P', portal);
 }

References conn, PqMsg_Describe, and PQsendTypedCommand().

Referenced by test_prepared().

◆ PQsendDescribePrepared()

int PQsendDescribePrepared	(	PGconn *	conn,
		const char *	stmt
	)

Definition at line 2457 of file fe-exec.c.

 {
     return PQsendTypedCommand(conn, PqMsg_Describe, 'S', stmt);
 }

References conn, PqMsg_Describe, PQsendTypedCommand(), and stmt.

Referenced by test_prepared().

◆ PQsendFlushRequest()

int PQsendFlushRequest ( PGconn * conn )

Definition at line 3293 of file fe-exec.c.

 {
     if (!conn)
         return 0;
  
     /* Don't try to send if we know there's no live connection. */
     if (conn->status != CONNECTION_OK)
     {
         libpq_append_conn_error(conn, "no connection to the server");
         return 0;
     }
  
     /* Can't send while already busy, either, unless enqueuing for later */
     if (conn->asyncStatus != PGASYNC_IDLE &&
         conn->pipelineStatus == PQ_PIPELINE_OFF)
     {
         libpq_append_conn_error(conn, "another command is already in progress");
         return 0;
     }
  
     if (pqPutMsgStart(PqMsg_Flush, conn) < 0 ||
         pqPutMsgEnd(conn) < 0)
     {
         return 0;
     }
  
     return 1;
 }

References pg_conn::asyncStatus, conn, CONNECTION_OK, libpq_append_conn_error(), PGASYNC_IDLE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PqMsg_Flush, pqPutMsgEnd(), pqPutMsgStart(), and pg_conn::status.

Referenced by test_nosync(), test_pipeline_idle(), test_singlerowmode(), and test_uniqviol().

◆ PQsendPrepare()

int PQsendPrepare	(	PGconn *	conn,
		const char *	stmtName,
		const char *	query,
		int	nParams,
		const Oid *	paramTypes
	)

Definition at line 1542 of file fe-exec.c.

 {
     PGcmdQueueEntry *entry = NULL;
  
     if (!PQsendQueryStart(conn, true))
         return 0;
  
     /* check the arguments */
     if (!stmtName)
     {
         libpq_append_conn_error(conn, "statement name is a null pointer");
         return 0;
     }
     if (!query)
     {
         libpq_append_conn_error(conn, "command string is a null pointer");
         return 0;
     }
     if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
     {
         libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
                                 PQ_QUERY_PARAM_MAX_LIMIT);
         return 0;
     }
  
     entry = pqAllocCmdQueueEntry(conn);
     if (entry == NULL)
         return 0;               /* error msg already set */
  
     /* construct the Parse message */
     if (pqPutMsgStart(PqMsg_Parse, conn) < 0 ||
         pqPuts(stmtName, conn) < 0 ||
         pqPuts(query, conn) < 0)
         goto sendFailed;
  
     if (nParams > 0 && paramTypes)
     {
         int         i;
  
         if (pqPutInt(nParams, 2, conn) < 0)
             goto sendFailed;
         for (i = 0; i < nParams; i++)
         {
             if (pqPutInt(paramTypes[i], 4, conn) < 0)
                 goto sendFailed;
         }
     }
     else
     {
         if (pqPutInt(0, 2, conn) < 0)
             goto sendFailed;
     }
     if (pqPutMsgEnd(conn) < 0)
         goto sendFailed;
  
     /* Add a Sync, unless in pipeline mode. */
     if (conn->pipelineStatus == PQ_PIPELINE_OFF)
     {
         if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
             pqPutMsgEnd(conn) < 0)
             goto sendFailed;
     }
  
     /* remember we are doing just a Parse */
     entry->queryclass = PGQUERY_PREPARE;
  
     /* and remember the query text too, if possible */
     /* if insufficient memory, query just winds up NULL */
     entry->query = strdup(query);
  
     /*
      * Give the data a push (in pipeline mode, only if we're past the size
      * threshold).  In nonblock mode, don't complain if we're unable to send
      * it all; PQgetResult() will do any additional flushing needed.
      */
     if (pqPipelineFlush(conn) < 0)
         goto sendFailed;
  
     /* OK, it's launched! */
     pqAppendCmdQueueEntry(conn, entry);
  
     return 1;
  
 sendFailed:
     pqRecycleCmdQueueEntry(conn, entry);
     /* error message should be set up already */
     return 0;
 }

References conn, i, libpq_append_conn_error(), PGQUERY_PREPARE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, PQ_QUERY_PARAM_MAX_LIMIT, pqAllocCmdQueueEntry(), pqAppendCmdQueueEntry(), PqMsg_Parse, PqMsg_Sync, pqPipelineFlush(), pqPutInt(), pqPutMsgEnd(), pqPutMsgStart(), pqPuts(), pqRecycleCmdQueueEntry(), PQsendQueryStart(), PGcmdQueueEntry::query, and PGcmdQueueEntry::queryclass.

Referenced by PQprepare(), prepare_foreign_modify(), test_pipelined_insert(), test_prepared(), and test_transaction().

◆ PQsendQuery()

int PQsendQuery	(	PGconn *	conn,
		const char *	query
	)

Definition at line 1422 of file fe-exec.c.

 {
     return PQsendQueryInternal(conn, query, true);
 }

References conn, and PQsendQueryInternal().

Referenced by advanceConnectionState(), BaseBackup(), dblink_send_query(), do_sql_command_begin(), ExecQueryAndProcessResults(), fetch_more_data_begin(), libpqrcv_PQexec(), pgfdw_exec_cleanup_query_begin(), pgfdw_exec_query(), pgfdw_finish_pre_commit_cleanup(), PQexec(), run_command(), run_permutation(), run_reindex_command(), run_vacuum_command(), sendCommand(), storeQueryResult(), and test_disallowed_in_pipeline().

◆ PQsendQueryContinue()

int PQsendQueryContinue	(	PGconn *	conn,
		const char *	query
	)

Definition at line 1428 of file fe-exec.c.

 {
     return PQsendQueryInternal(conn, query, false);
 }

References conn, and PQsendQueryInternal().

Referenced by PQconnectPoll().

◆ PQsendQueryGuts()

static int PQsendQueryGuts	(	PGconn *	conn,
		const char *	command,
		const char *	stmtName,
		int	nParams,
		const Oid *	paramTypes,
		const char const	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

static

Definition at line 1761 of file fe-exec.c.

 {
     int         i;
     PGcmdQueueEntry *entry;
  
     entry = pqAllocCmdQueueEntry(conn);
     if (entry == NULL)
         return 0;               /* error msg already set */
  
     /*
      * We will send Parse (if needed), Bind, Describe Portal, Execute, Sync
      * (if not in pipeline mode), using specified statement name and the
      * unnamed portal.
      */
  
     if (command)
     {
         /* construct the Parse message */
         if (pqPutMsgStart(PqMsg_Parse, conn) < 0 ||
             pqPuts(stmtName, conn) < 0 ||
             pqPuts(command, conn) < 0)
             goto sendFailed;
         if (nParams > 0 && paramTypes)
         {
             if (pqPutInt(nParams, 2, conn) < 0)
                 goto sendFailed;
             for (i = 0; i < nParams; i++)
             {
                 if (pqPutInt(paramTypes[i], 4, conn) < 0)
                     goto sendFailed;
             }
         }
         else
         {
             if (pqPutInt(0, 2, conn) < 0)
                 goto sendFailed;
         }
         if (pqPutMsgEnd(conn) < 0)
             goto sendFailed;
     }
  
     /* Construct the Bind message */
     if (pqPutMsgStart(PqMsg_Bind, conn) < 0 ||
         pqPuts("", conn) < 0 ||
         pqPuts(stmtName, conn) < 0)
         goto sendFailed;
  
     /* Send parameter formats */
     if (nParams > 0 && paramFormats)
     {
         if (pqPutInt(nParams, 2, conn) < 0)
             goto sendFailed;
         for (i = 0; i < nParams; i++)
         {
             if (pqPutInt(paramFormats[i], 2, conn) < 0)
                 goto sendFailed;
         }
     }
     else
     {
         if (pqPutInt(0, 2, conn) < 0)
             goto sendFailed;
     }
  
     if (pqPutInt(nParams, 2, conn) < 0)
         goto sendFailed;
  
     /* Send parameters */
     for (i = 0; i < nParams; i++)
     {
         if (paramValues && paramValues[i])
         {
             int         nbytes;
  
             if (paramFormats && paramFormats[i] != 0)
             {
                 /* binary parameter */
                 if (paramLengths)
                     nbytes = paramLengths[i];
                 else
                 {
                     libpq_append_conn_error(conn, "length must be given for binary parameter");
                     goto sendFailed;
                 }
             }
             else
             {
                 /* text parameter, do not use paramLengths */
                 nbytes = strlen(paramValues[i]);
             }
             if (pqPutInt(nbytes, 4, conn) < 0 ||
                 pqPutnchar(paramValues[i], nbytes, conn) < 0)
                 goto sendFailed;
         }
         else
         {
             /* take the param as NULL */
             if (pqPutInt(-1, 4, conn) < 0)
                 goto sendFailed;
         }
     }
     if (pqPutInt(1, 2, conn) < 0 ||
         pqPutInt(resultFormat, 2, conn))
         goto sendFailed;
     if (pqPutMsgEnd(conn) < 0)
         goto sendFailed;
  
     /* construct the Describe Portal message */
     if (pqPutMsgStart(PqMsg_Describe, conn) < 0 ||
         pqPutc('P', conn) < 0 ||
         pqPuts("", conn) < 0 ||
         pqPutMsgEnd(conn) < 0)
         goto sendFailed;
  
     /* construct the Execute message */
     if (pqPutMsgStart(PqMsg_Execute, conn) < 0 ||
         pqPuts("", conn) < 0 ||
         pqPutInt(0, 4, conn) < 0 ||
         pqPutMsgEnd(conn) < 0)
         goto sendFailed;
  
     /* construct the Sync message if not in pipeline mode */
     if (conn->pipelineStatus == PQ_PIPELINE_OFF)
     {
         if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
             pqPutMsgEnd(conn) < 0)
             goto sendFailed;
     }
  
     /* remember we are using extended query protocol */
     entry->queryclass = PGQUERY_EXTENDED;
  
     /* and remember the query text too, if possible */
     /* if insufficient memory, query just winds up NULL */
     if (command)
         entry->query = strdup(command);
  
     /*
      * Give the data a push (in pipeline mode, only if we're past the size
      * threshold).  In nonblock mode, don't complain if we're unable to send
      * it all; PQgetResult() will do any additional flushing needed.
      */
     if (pqPipelineFlush(conn) < 0)
         goto sendFailed;
  
     /* OK, it's launched! */
     pqAppendCmdQueueEntry(conn, entry);
  
     return 1;
  
 sendFailed:
     pqRecycleCmdQueueEntry(conn, entry);
     /* error message should be set up already */
     return 0;
 }

References conn, i, libpq_append_conn_error(), PGQUERY_EXTENDED, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqAllocCmdQueueEntry(), pqAppendCmdQueueEntry(), PqMsg_Bind, PqMsg_Describe, PqMsg_Execute, PqMsg_Parse, PqMsg_Sync, pqPipelineFlush(), pqPutc(), pqPutInt(), pqPutMsgEnd(), pqPutMsgStart(), pqPutnchar(), pqPuts(), pqRecycleCmdQueueEntry(), PGcmdQueueEntry::query, and PGcmdQueueEntry::queryclass.

Referenced by PQsendQueryParams(), and PQsendQueryPrepared().

◆ PQsendQueryInternal()

static int PQsendQueryInternal	(	PGconn *	conn,
		const char *	query,
		bool	newQuery
	)

static

Definition at line 1434 of file fe-exec.c.

 {
     PGcmdQueueEntry *entry = NULL;
  
     if (!PQsendQueryStart(conn, newQuery))
         return 0;
  
     /* check the argument */
     if (!query)
     {
         libpq_append_conn_error(conn, "command string is a null pointer");
         return 0;
     }
  
     if (conn->pipelineStatus != PQ_PIPELINE_OFF)
     {
         libpq_append_conn_error(conn, "%s not allowed in pipeline mode",
                                 "PQsendQuery");
         return 0;
     }
  
     entry = pqAllocCmdQueueEntry(conn);
     if (entry == NULL)
         return 0;               /* error msg already set */
  
     /* Send the query message(s) */
     /* construct the outgoing Query message */
     if (pqPutMsgStart(PqMsg_Query, conn) < 0 ||
         pqPuts(query, conn) < 0 ||
         pqPutMsgEnd(conn) < 0)
     {
         /* error message should be set up already */
         pqRecycleCmdQueueEntry(conn, entry);
         return 0;
     }
  
     /* remember we are using simple query protocol */
     entry->queryclass = PGQUERY_SIMPLE;
     /* and remember the query text too, if possible */
     entry->query = strdup(query);
  
     /*
      * Give the data a push.  In nonblock mode, don't complain if we're unable
      * to send it all; PQgetResult() will do any additional flushing needed.
      */
     if (pqFlush(conn) < 0)
         goto sendFailed;
  
     /* OK, it's launched! */
     pqAppendCmdQueueEntry(conn, entry);
  
     return 1;
  
 sendFailed:
     pqRecycleCmdQueueEntry(conn, entry);
     /* error message should be set up already */
     return 0;
 }

References conn, libpq_append_conn_error(), PGQUERY_SIMPLE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqAllocCmdQueueEntry(), pqAppendCmdQueueEntry(), pqFlush(), PqMsg_Query, pqPutMsgEnd(), pqPutMsgStart(), pqPuts(), pqRecycleCmdQueueEntry(), PQsendQueryStart(), PGcmdQueueEntry::query, and PGcmdQueueEntry::queryclass.

Referenced by PQsendQuery(), and PQsendQueryContinue().

◆ PQsendQueryParams()

int PQsendQueryParams	(	PGconn *	conn,
		const char *	command,
		int	nParams,
		const Oid *	paramTypes,
		const char const	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

Definition at line 1498 of file fe-exec.c.

 {
     if (!PQsendQueryStart(conn, true))
         return 0;
  
     /* check the arguments */
     if (!command)
     {
         libpq_append_conn_error(conn, "command string is a null pointer");
         return 0;
     }
     if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
     {
         libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
                                 PQ_QUERY_PARAM_MAX_LIMIT);
         return 0;
     }
  
     return PQsendQueryGuts(conn,
                            command,
                            "",  /* use unnamed statement */
                            nParams,
                            paramTypes,
                            paramValues,
                            paramLengths,
                            paramFormats,
                            resultFormat);
 }

References conn, libpq_append_conn_error(), PQ_QUERY_PARAM_MAX_LIMIT, PQsendQueryGuts(), and PQsendQueryStart().

Referenced by create_cursor(), ExecQueryAndProcessResults(), execute_dml_stmt(), PQexecParams(), sendCommand(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_simple_pipeline(), test_singlerowmode(), and test_transaction().

◆ PQsendQueryPrepared()

int PQsendQueryPrepared	(	PGconn *	conn,
		const char *	stmtName,
		int	nParams,
		const char const	paramValues,
		const int *	paramLengths,
		const int *	paramFormats,
		int	resultFormat
	)

Definition at line 1639 of file fe-exec.c.

 {
     if (!PQsendQueryStart(conn, true))
         return 0;
  
     /* check the arguments */
     if (!stmtName)
     {
         libpq_append_conn_error(conn, "statement name is a null pointer");
         return 0;
     }
     if (nParams < 0 || nParams > PQ_QUERY_PARAM_MAX_LIMIT)
     {
         libpq_append_conn_error(conn, "number of parameters must be between 0 and %d",
                                 PQ_QUERY_PARAM_MAX_LIMIT);
         return 0;
     }
  
     return PQsendQueryGuts(conn,
                            NULL,    /* no command to parse */
                            stmtName,
                            nParams,
                            NULL,    /* no param types */
                            paramValues,
                            paramLengths,
                            paramFormats,
                            resultFormat);
 }

References conn, libpq_append_conn_error(), PQ_QUERY_PARAM_MAX_LIMIT, PQsendQueryGuts(), and PQsendQueryStart().

Referenced by execute_foreign_modify(), PQexecPrepared(), process_queued_fetch_requests(), sendCommand(), test_pipelined_insert(), test_transaction(), and test_uniqviol().

◆ PQsendQueryStart()

static bool PQsendQueryStart	(	PGconn *	conn,
		bool	newQuery
	)

static

Definition at line 1679 of file fe-exec.c.

 {
     if (!conn)
         return false;
  
     /*
      * If this is the beginning of a query cycle, reset the error state.
      * However, in pipeline mode with something already queued, the error
      * buffer belongs to that command and we shouldn't clear it.
      */
     if (newQuery && conn->cmd_queue_head == NULL)
         pqClearConnErrorState(conn);
  
     /* Don't try to send if we know there's no live connection. */
     if (conn->status != CONNECTION_OK)
     {
         libpq_append_conn_error(conn, "no connection to the server");
         return false;
     }
  
     /* Can't send while already busy, either, unless enqueuing for later */
     if (conn->asyncStatus != PGASYNC_IDLE &&
         conn->pipelineStatus == PQ_PIPELINE_OFF)
     {
         libpq_append_conn_error(conn, "another command is already in progress");
         return false;
     }
  
     if (conn->pipelineStatus != PQ_PIPELINE_OFF)
     {
         /*
          * When enqueuing commands we don't change much of the connection
          * state since it's already in use for the current command. The
          * connection state will get updated when pqPipelineProcessQueue()
          * advances to start processing the queued message.
          *
          * Just make sure we can safely enqueue given the current connection
          * state. We can enqueue behind another queue item, or behind a
          * non-queue command (one that sends its own sync), but we can't
          * enqueue if the connection is in a copy state.
          */
         switch (conn->asyncStatus)
         {
             case PGASYNC_IDLE:
             case PGASYNC_PIPELINE_IDLE:
             case PGASYNC_READY:
             case PGASYNC_READY_MORE:
             case PGASYNC_BUSY:
                 /* ok to queue */
                 break;
  
             case PGASYNC_COPY_IN:
             case PGASYNC_COPY_OUT:
             case PGASYNC_COPY_BOTH:
                 libpq_append_conn_error(conn, "cannot queue commands during COPY");
                 return false;
         }
     }
     else
     {
         /*
          * This command's results will come in immediately. Initialize async
          * result-accumulation state
          */
         pqClearAsyncResult(conn);
  
         /* reset single-row processing mode */
         conn->singleRowMode = false;
     }
  
     /* ready to send command message */
     return true;
 }

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, CONNECTION_OK, libpq_append_conn_error(), PGASYNC_BUSY, PGASYNC_COPY_BOTH, PGASYNC_COPY_IN, PGASYNC_COPY_OUT, PGASYNC_IDLE, PGASYNC_PIPELINE_IDLE, PGASYNC_READY, PGASYNC_READY_MORE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqClearAsyncResult(), pqClearConnErrorState, pg_conn::singleRowMode, and pg_conn::status.

Referenced by PQsendPrepare(), PQsendQueryInternal(), PQsendQueryParams(), PQsendQueryPrepared(), and PQsendTypedCommand().

◆ PQsendTypedCommand()

static int PQsendTypedCommand	(	PGconn *	conn,
		char	command,
		char	type,
		const char *	target
	)

static

Definition at line 2555 of file fe-exec.c.

 {
     PGcmdQueueEntry *entry = NULL;
  
     /* Treat null target as empty string */
     if (!target)
         target = "";
  
     if (!PQsendQueryStart(conn, true))
         return 0;
  
     entry = pqAllocCmdQueueEntry(conn);
     if (entry == NULL)
         return 0;               /* error msg already set */
  
     /* construct the Close message */
     if (pqPutMsgStart(command, conn) < 0 ||
         pqPutc(type, conn) < 0 ||
         pqPuts(target, conn) < 0 ||
         pqPutMsgEnd(conn) < 0)
         goto sendFailed;
  
     /* construct the Sync message */
     if (conn->pipelineStatus == PQ_PIPELINE_OFF)
     {
         if (pqPutMsgStart(PqMsg_Sync, conn) < 0 ||
             pqPutMsgEnd(conn) < 0)
             goto sendFailed;
     }
  
     /* remember if we are doing a Close or a Describe */
     if (command == PqMsg_Close)
     {
         entry->queryclass = PGQUERY_CLOSE;
     }
     else if (command == PqMsg_Describe)
     {
         entry->queryclass = PGQUERY_DESCRIBE;
     }
     else
     {
         libpq_append_conn_error(conn, "unknown command type provided");
         goto sendFailed;
     }
  
     /*
      * Give the data a push (in pipeline mode, only if we're past the size
      * threshold).  In nonblock mode, don't complain if we're unable to send
      * it all; PQgetResult() will do any additional flushing needed.
      */
     if (pqPipelineFlush(conn) < 0)
         goto sendFailed;
  
     /* OK, it's launched! */
     pqAppendCmdQueueEntry(conn, entry);
  
     return 1;
  
 sendFailed:
     pqRecycleCmdQueueEntry(conn, entry);
     /* error message should be set up already */
     return 0;
 }

References conn, libpq_append_conn_error(), PGQUERY_CLOSE, PGQUERY_DESCRIBE, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqAllocCmdQueueEntry(), pqAppendCmdQueueEntry(), PqMsg_Close, PqMsg_Describe, PqMsg_Sync, pqPipelineFlush(), pqPutc(), pqPutMsgEnd(), pqPutMsgStart(), pqPuts(), pqRecycleCmdQueueEntry(), PQsendQueryStart(), PGcmdQueueEntry::queryclass, and type.

Referenced by PQclosePortal(), PQclosePrepared(), PQdescribePortal(), PQdescribePrepared(), PQsendClosePortal(), PQsendClosePrepared(), PQsendDescribePortal(), and PQsendDescribePrepared().

◆ PQsetnonblocking()

int PQsetnonblocking	(	PGconn *	conn,
		int	arg
	)

Definition at line 3858 of file fe-exec.c.

 {
     bool        barg;
  
     if (!conn || conn->status == CONNECTION_BAD)
         return -1;
  
     barg = (arg ? true : false);
  
     /* early out if the socket is already in the state requested */
     if (barg == conn->nonblocking)
         return 0;
  
     /*
      * to guarantee constancy for flushing/query/result-polling behavior we
      * need to flush the send queue at this point in order to guarantee proper
      * behavior. this is ok because either they are making a transition _from_
      * or _to_ blocking mode, either way we can block them.
      *
      * Clear error state in case pqFlush adds to it, unless we're actively
      * pipelining, in which case it seems best not to.
      */
     if (

Macros

Functions

Variables

Macro Definition Documentation

◆ ISFIRSTOCTDIGIT

◆ ISOCTDIGIT

◆ OCTVAL

◆ PGRESULT_ALIGN_BOUNDARY

◆ PGRESULT_BLOCK_OVERHEAD

◆ PGRESULT_DATA_BLOCKSIZE

◆ PGRESULT_SEP_ALLOC_THRESHOLD

Function Documentation

◆ check_field_number()

◆ check_param_number()

◆ check_tuple_field_number()

◆ dupEvents()

◆ get_hex()

◆ getCopyResult()

◆ parseInput()

◆ pqAddTuple()

◆ pqAllocCmdQueueEntry()

◆ pqAppendCmdQueueEntry()

◆ PQbinaryTuples()

◆ PQclear()

◆ pqClearAsyncResult()

◆ PQclosePortal()

◆ PQclosePrepared()

◆ PQcmdStatus()

◆ PQcmdTuples()

◆ pqCommandQueueAdvance()

◆ PQconsumeInput()

◆ PQcopyResult()

◆ PQdescribePortal()

◆ PQdescribePrepared()

◆ PQendcopy()

◆ PQenterPipelineMode()

◆ PQescapeBytea()

◆ PQescapeByteaConn()

◆ PQescapeByteaInternal()

◆ PQescapeIdentifier()

◆ PQescapeInternal()

◆ PQescapeLiteral()

◆ PQescapeString()

◆ PQescapeStringConn()

◆ PQescapeStringInternal()

◆ PQexec()

◆ PQexecFinish()

◆ PQexecParams()

◆ PQexecPrepared()

◆ PQexecStart()

◆ PQexitPipelineMode()

◆ PQfformat()

◆ PQflush()

◆ PQfmod()

◆ PQfn()

◆ PQfname()

◆ PQfnumber()

◆ PQfreemem()

◆ PQfreeNotify()

◆ PQfsize()

◆ PQftable()

◆ PQftablecol()

◆ PQftype()

◆ PQgetCopyData()

◆ PQgetisnull()

◆ PQgetlength()

◆ PQgetline()

◆ PQgetlineAsync()

◆ PQgetResult()

◆ PQgetvalue()

◆ pqInternalNotice()

◆ PQisBusy()

◆ PQisnonblocking()

◆ PQisthreadsafe()

◆ PQmakeEmptyPGresult()

◆ PQnfields()

◆ PQnotifies()

◆ PQnparams()

◆ PQntuples()

◆ PQoidStatus()