#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	pqPipelineSyncInternal (PGconn *conn, bool immediate_flush)

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)

static bool	canChangeResultMode (PGconn *conn)

int	PQsetSingleRowMode (PGconn *conn)

int	PQsetChunkedRowsMode (PGconn *conn, int chunkSize)

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, bool isReadyForQuery, bool gotSync)

int	PQpipelineSync (PGconn *conn)

int	PQsendPipelineSync (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 4477 of file fe-exec.c.

◆ ISOCTDIGIT

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

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

◆ OCTVAL

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

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

◆ PGRESULT_ALIGN_BOUNDARY

#define PGRESULT_ALIGN_BOUNDARY MAXIMUM_ALIGNOF /* from configure */

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

◆ PGRESULT_BLOCK_OVERHEAD

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

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

◆ PGRESULT_DATA_BLOCKSIZE

#define PGRESULT_DATA_BLOCKSIZE 2048

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

◆ PGRESULT_SEP_ALLOC_THRESHOLD

#define PGRESULT_SEP_ALLOC_THRESHOLD (PGRESULT_DATA_BLOCKSIZE / 2)

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

Function Documentation

◆ canChangeResultMode()

static bool canChangeResultMode ( PGconn * conn )

static

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

 {
     /*
      * Only allow changing the mode when we have launched a query and not yet
      * received any results.
      */
     if (!conn)
         return false;
     if (conn->asyncStatus != PGASYNC_BUSY)
         return false;
     if (!conn->cmd_queue_head ||
         (conn->cmd_queue_head->queryclass != PGQUERY_SIMPLE &&
          conn->cmd_queue_head->queryclass != PGQUERY_EXTENDED))
         return false;
     if (pgHavePendingResult(conn))
         return false;
     return true;
 }

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, PGASYNC_BUSY, pgHavePendingResult, PGQUERY_EXTENDED, PGQUERY_SIMPLE, and PGcmdQueueEntry::queryclass.

Referenced by PQsetChunkedRowsMode(), and PQsetSingleRowMode().

◆ check_field_number()

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

static

Definition at line 3510 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 3548 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 3525 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 408 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 4330 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 2224 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 2020 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 993 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 1306 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 pqPipelineSyncInternal(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and PQsendTypedCommand().

◆ pqAppendCmdQueueEntry()

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

static

Definition at line 1339 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 pqPipelineSyncInternal(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and PQsendTypedCommand().

◆ PQbinaryTuples()

int PQbinaryTuples ( const PGresult * res )

Definition at line 3497 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 721 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(), and PQmakeEmptyPGresult().

◆ pqClearAsyncResult()

void pqClearAsyncResult ( PGconn * conn )

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

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

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

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

◆ PQclosePortal()

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

Definition at line 2539 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 2521 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 3752 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(), PrintQueryStatus(), and test_pipelined_insert().

◆ PQcmdTuples()

char* PQcmdTuples ( PGresult * res )

Definition at line 3822 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,
		bool	isReadyForQuery,
		bool	gotSync
	)

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

 {
     PGcmdQueueEntry *prevquery;
  
     if (conn->cmd_queue_head == NULL)
         return;
  
     /*
      * If processing a query of simple query protocol, we only advance the
      * queue when we receive the ReadyForQuery message for it.
      */
     if (conn->cmd_queue_head->queryclass == PGQUERY_SIMPLE && !isReadyForQuery)
         return;
  
     /*
      * If we're waiting for a SYNC, don't advance the queue until we get one.
      */
     if (conn->cmd_queue_head->queryclass == PGQUERY_SYNC && !gotSync)
         return;
  
     /* delink element 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 the queue element recyclable */
     prevquery->next = NULL;
     pqRecycleCmdQueueEntry(conn, prevquery);
 }

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

Referenced by PQgetResult(), and pqParseInput3().

◆ PQconsumeInput()

int PQconsumeInput ( PGconn * conn )

Definition at line 1984 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(), confirm_query_canceled_impl(), CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), do_sql_command_end(), ecpg_process_output(), libpqrcv_PQgetResult(), libpqrcv_receive(), libpqsrv_get_result(), main(), pgfdw_cancel_query_end(), pgfdw_exec_cleanup_query_end(), pgfdw_get_cleanup_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 318 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 2474 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 2455 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 2949 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 3042 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 4469 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 4453 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 4357 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 4310 of file fe-exec.c.

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

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

Referenced by create_publication(), create_subscription(), drop_publication(), enable_subscription(), initCreatePKeys(), initCreateTables(), main(), PQchangePassword(), 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 4182 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 str.

Referenced by PQescapeIdentifier(), and PQescapeLiteral().

◆ PQescapeLiteral()

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

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

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

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

Referenced by check_publisher(), create_logical_replication_slot(), create_publication(), create_subscription(), DescribeQuery(), drop_replication_slot(), libpqrcv_startstreaming(), PQchangePassword(), psql_get_variable(), set_locale_and_encoding(), and set_replication_progress().

◆ PQescapeString()

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

Definition at line 4167 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 4145 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 4071 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 2262 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(), check_publisher(), check_subscriber(), connect_database(), create_logical_replication_slot(), create_publication(), create_subscription(), CreateReplicationSlot(), deallocate_one(), DescribeQuery(), drop_publication(), drop_replication_slot(), DropReplicationSlot(), ecpg_autostart_transaction(), ecpg_execute(), ECPGsetcommit(), ECPGtrans(), enable_subscription(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), generate_object_name(), get_create_object_cmd(), get_primary_sysid(), GetConnection(), GetSlotInformation(), GetTableInfo(), init_libpq_conn(), initPopulateTable(), libpq_traverse_files(), lo_initialize(), lockTableForWorker(), lookup_object_oid(), main(), PQchangePassword(), PQencryptPasswordConn(), PQsetClientEncoding(), PSQLexec(), ReceiveXlogStream(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), SendQuery(), server_is_in_recovery(), set_replication_progress(), sql_conn(), sql_exec(), StreamLogicalLog(), test_disallowed_in_pipeline(), test_pipeline_abort(), test_prepared(), test_transaction(), test_uniqviol(), tryExecuteStatement(), vacuumlo(), and wait_for_end_recovery().

◆ PQexecFinish()

static PGresult * PQexecFinish ( PGconn * conn )

static

Definition at line 2410 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 2276 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(), main(), and wait_for_connection_state().

◆ 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 2323 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 2344 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 3073 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 3708 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 4000 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(), prepareToTerminate(), ProcessXLogDataMsg(), sendFeedback(), test_nosync(), test_pipelined_insert(), and test_uniqviol().

◆ PQfmod()

int PQfmod	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3741 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 2980 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 3567 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 3589 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_old_cluster_logical_slot_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(), getSubscriptionTables(), 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 4032 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(), get_base_conninfo(), handleCopyOut(), HandleCopyStream(), HandleEndOfCopyStream(), initCreatePKeys(), initCreateTables(), libpqrcv_check_conninfo(), libpqrcv_disconnect(), libpqrcv_get_dbname_from_conninfo(), libpqrcv_receive(), libpqrcv_startstreaming(), main(), PQchangePassword(), 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 4049 of file fe-exec.c.

 {
     PQfreemem(notify);
 }

References PQfreemem().

◆ PQfsize()

int PQfsize	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3730 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 3686 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 3697 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 3719 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 2816 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 3901 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(), getExtendedStatistics(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getLOs(), getNamespaces(), getPolicies(), getProcLangs(), getPublicationTables(), GetSlotInformation(), getSubscriptions(), getSubscriptionTables(), getTableAttrs(), GetTableInfo(), getTables(), 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 3887 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 2854 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 2901 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 2062 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:
             res = pqPrepareAsyncResult(conn);
  
             /*
              * Normally pqPrepareAsyncResult will have left conn->result
              * empty.  Otherwise, "res" must be a not-full PGRES_TUPLES_CHUNK
              * result, which we want to return to the caller while staying in
              * PGASYNC_READY state.  Then the next call here will return the
              * empty PGRES_TUPLES_OK result that was restored from
              * saved_result, after which we can proceed.
              */
             if (conn->result)
             {
                 Assert(res->resultStatus == PGRES_TUPLES_CHUNK);
                 break;
             }
  
             /* Advance the queue as appropriate */
             pqCommandQueueAdvance(conn, false,
                                   res->resultStatus == PGRES_PIPELINE_SYNC);
  
             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->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, 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, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_PIPELINE_SYNC, PGRES_TUPLES_CHUNK, pg_conn::pipelineStatus, PQ_PIPELINE_OFF, pqCommandQueueAdvance(), PQfireResultCreateEvents(), pqFlush(), pqPipelineProcessQueue(), pqPrepareAsyncResult(), pqReadData(), pqSaveErrorResult(), pqSaveWriteError(), pqWait(), res, pg_conn::result, pg_result::resultStatus, and pg_conn::write_failed.

Referenced by advanceConnectionState(), BaseBackup(), ClearOrSaveAllResults(), confirm_query_canceled_impl(), consumeQueryResult(), discardUntilSync(), dumpTableData_copy(), ecpg_process_output(), EndDBCopyMode(), ExecQueryAndProcessResults(), handleCopyIn(), handleCopyOut(), HandleEndOfCopyStream(), libpqrcv_PQgetResult(), libpqsrv_get_result(), pgfdw_finish_pre_commit_cleanup(), pgfdw_get_cleanup_result(), PQconnectPoll(), pqEndcopy3(), PQexecFinish(), PQexecStart(), process_queued_fetch_requests(), process_result(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), 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 3876 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_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), check_proper_datallowconn(), check_publisher(), check_subscriber(), cluster_all_databases(), collectComments(), collectRoleNames(), collectSecLabels(), compile_database_list(), compile_relation_list_one_db(), convertTSFunction(), create_logical_replication_slot(), createViewAsClause(), describeOneTableDetails(), describePublications(), describeRoles(), describeTableDetails(), do_field(), dropDBs(), dropRoles(), dropTablespaces(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpDomain(), dumpEnumType(), dumpForeignServer(), dumpFunc(), 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(), generate_object_name(), get_create_object_cmd(), get_db_infos(), get_db_subscription_count(), get_language_name(), get_loadable_libraries(), get_next_possible_free_pg_type_oid(), get_old_cluster_logical_slot_infos(), get_parallel_object_list(), get_primary_sysid(), 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(), getSubscriptionTables(), 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(), server_is_in_recovery(), set_frozenxids(), set_replication_progress(), 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(), verify_heap_slot_handler(), and wait_for_connection_state().

◆ pqInternalNotice()

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

Definition at line 938 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 2031 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(), confirm_query_canceled_impl(), dblink_is_busy(), libpqrcv_PQgetResult(), libpqsrv_get_result(), pgfdw_get_cleanup_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 3983 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 3992 of file fe-exec.c.

 {
     return true;
 }

◆ PQmakeEmptyPGresult()

PGresult* PQmakeEmptyPGresult	(	PGconn *	conn,
		ExecStatusType	status
	)

Definition at line 159 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:
             case PGRES_TUPLES_CHUNK:
                 /* 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_CHUNK, 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 3489 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(), test_prepared(), and wait_for_connection_state().

◆ PQnotifies()

PGnotify* PQnotifies ( PGconn * conn )

Definition at line 2667 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 3915 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 3481 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_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), check_proper_datallowconn(), check_publisher(), cluster_all_databases(), collectComments(), collectRoleNames(), collectSecLabels(), compile_database_list(), compile_relation_list_one_db(), create_publication(), CreateReplicationSlot(), createViewAsClause(), describeOneTableDetails(), describePublications(), describeRoles(), describeTableDetails(), dropDBs(), DropReplicationSlot(), dropRoles(), dropTablespaces(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpEnumType(), 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(), 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(), generate_object_name(), get_create_object_cmd(), get_db_infos(), get_loadable_libraries(), get_old_cluster_logical_slot_infos(), get_parallel_object_list(), get_primary_sysid(), 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(), getSubscriptionTables(), 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(), set_replication_progress(), 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(), verify_heap_slot_handler(), wait_for_connection_state(), and wait_for_end_recovery().

◆ PQoidStatus()

char* PQoidStatus ( const PGresult * res )

Definition at line 3765 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 3793 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 3926 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 4016 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 pqPipelineSyncInternal(), PQsendFlushRequest(), PQsendPrepare(), PQsendQueryGuts(), and PQsendTypedCommand().

◆ pqPipelineProcessQueue()

static void pqPipelineProcessQueue ( PGconn * conn )

static

Definition at line 3180 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 partial-result mode.  (Client has to set it up for each query, if
      * desired.)
      */
     conn->partialResMode = false;
     conn->singleRowMode = false;
     conn->maxChunkSize = 0;
  
     /*
      * 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(), pg_conn::maxChunkSize, pg_conn::partialResMode, 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 3272 of file fe-exec.c.

 {
     return pqPipelineSyncInternal(conn, true);
 }

References conn, and pqPipelineSyncInternal().

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

◆ pqPipelineSyncInternal()

static int pqPipelineSyncInternal	(	PGconn *	conn,
		bool	immediate_flush
	)

static

Definition at line 3294 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 immediate_flush is disabled, the data is pushed if we are past the
      * size threshold.
      */
     if (immediate_flush)
     {
         if (pqFlush(conn) < 0)
             goto sendFailed;
     }
     else
     {
         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 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, pqPipelineFlush(), pqPutMsgEnd(), pqPutMsgStart(), pqRecycleCmdQueueEntry(), PGcmdQueueEntry::query, and PGcmdQueueEntry::queryclass.

Referenced by PQpipelineSync(), and PQsendPipelineSync().

◆ PQprepare()

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

Definition at line 2306 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 851 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 saved_result, if any.  In the normal case
      * there isn't a saved result and we're just dropping ownership of the
      * current result.  In partial-result mode this restores the situation to
      * what it was before we created the current partial result.
      */
     conn->result = conn->saved_result;
     conn->error_result = false; /* saved_result is never an error */
     conn->saved_result = NULL;
  
     return res;
 }

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

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

◆ PQputCopyData()

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

Definition at line 2695 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 BaseBackup(), ExecuteSqlCommandBuf(), handleCopyIn(), libpqrcv_send(), PQputnbytes(), and sendFeedback().

◆ PQputCopyEnd()

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

Definition at line 2749 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 BaseBackup(), CheckCopyStreamStop(), EndDBCopyMode(), handleCopyIn(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), PQexecStart(), prepareToTerminate(), and ProcessXLogDataMsg().

◆ PQputline()

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

Definition at line 2918 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 2928 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 1386 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(), pqPipelineSyncInternal(), PQsendPrepare(), PQsendQueryGuts(), PQsendQueryInternal(), and PQsendTypedCommand().

◆ PQresStatus()

char* PQresStatus ( ExecStatusType status )

Definition at line 3419 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 BaseBackup(), 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 543 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 563 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 3466 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(), confirm_query_canceled_impl(), 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 3427 of file fe-exec.c.

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

References pg_result::errMsg, and res.

Referenced by check_publisher(), check_subscriber(), connect_database(), create_logical_replication_slot(), create_publication(), create_subscription(), defaultNoticeReceiver(), drop_publication(), drop_replication_slot(), ecpg_check_PQresult(), ecpg_process_output(), enable_subscription(), ExecQueryAndProcessResults(), generate_object_name(), get_primary_sysid(), init_libpq_conn(), libpq_fetch_file(), libpq_traverse_files(), process_queued_fetch_requests(), ReceiveXlogStream(), run_simple_command(), run_simple_query(), server_is_in_recovery(), set_replication_progress(), StreamLogicalLog(), test_pipeline_abort(), and try_complete_step().

◆ PQresultMemorySize()

size_t PQresultMemorySize ( const PGresult * res )

Definition at line 663 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 3411 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(), check_publisher(), check_subscriber(), ClearOrSaveResult(), close_cursor(), compile_database_list(), compile_relation_list_one_db(), confirm_query_canceled_impl(), connect_database(), create_cursor(), create_logical_replication_slot(), create_publication(), create_subscription(), CreateReplicationSlot(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), dblink_record_internal(), deallocate_query(), DescribeQuery(), discardUntilSync(), do_sql_command_end(), drop_publication(), drop_replication_slot(), DropReplicationSlot(), dumpTableData_copy(), ecpg_check_PQresult(), ecpg_process_output(), enable_subscription(), EndDBCopyMode(), exec_command_password(), ExecQueryAndProcessResults(), execute_dml_stmt(), execute_foreign_modify(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), fetch_more_data(), generate_object_name(), get_create_object_cmd(), get_primary_sysid(), get_remote_estimate(), GetConnection(), GetSlotInformation(), GetTableInfo(), handleCopyIn(), handleCopyOut(), HandleCopyResult(), HandleEndOfCopyStream(), init_libpq_conn(), initPopulateTable(), libpq_fetch_file(), libpq_traverse_files(), libpqrcv_alter_slot(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_PQexec(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_startstreaming(), libpqsrv_get_result_last(), 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(), PrintQueryStatus(), PrintResultInCrosstab(), process_queued_fetch_requests(), process_result(), readCommandResponse(), ReceiveCopyData(), ReceiveXlogStream(), RetrieveDataDirCreatePerm(), RetrieveWalSegSize(), run_permutation(), run_simple_command(), run_simple_query(), RunIdentifySystem(), SendQuery(), server_is_in_recovery(), set_replication_progress(), 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(), verify_heap_slot_handler(), and wait_for_connection_state().

◆ pqResultStrdup()

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

Definition at line 675 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 str.

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

◆ PQresultVerboseErrorMessage()

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

Definition at line 3435 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 partial-result mode, if we don't already have a partial PGresult
      * then make one by cloning conn->result (which should hold the correct
      * result metadata by now).  Then the original conn->result is moved over
      * to saved_result so that we can re-use it as a reference for future
      * partial results.  The saved result will become active again after
      * pqPrepareAsyncResult() returns the partial result to the application.
      */
     if (conn->partialResMode && conn->saved_result == NULL)
     {
         /* 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;
         /* Change result status to appropriate special value */
         res->resultStatus = (conn->singleRowMode ? PGRES_SINGLE_TUPLE : PGRES_TUPLES_CHUNK);
         /* And stash it as the active result */
         conn->saved_result = conn->result;
         conn->result = res;
     }
  
     /*
      * 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)
         return 0;
  
     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)
                 return 0;
  
             /* 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))
         return 0;
  
     /*
      * Success.  In partial-result mode, if we have enough rows then make the
      * result available to the client immediately.
      */
     if (conn->partialResMode && res->ntups >= conn->maxChunkSize)
         conn->asyncStatus = PGASYNC_READY_MORE;
  
     return 1;
 }

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

Referenced by getAnotherTuple().

◆ pqSaveErrorResult()

void pqSaveErrorResult ( PGconn * conn )

Definition at line 803 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 1060 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 1081 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 820 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 2569 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 2556 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 2504 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 2491 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 3371 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;
     }
  
     /*
      * 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)
         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, pqPipelineFlush(), pqPutMsgEnd(), pqPutMsgStart(), and pg_conn::status.

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

◆ PQsendPipelineSync()

int PQsendPipelineSync ( PGconn * conn )

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

 {
     return pqPipelineSyncInternal(conn, false);
 }

References conn, and pqPipelineSyncInternal().

Referenced by executeMetaCommand(), and test_multi_pipelines().

◆ PQsendPrepare()

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

Definition at line 1536 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 1416 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(), libpqsrv_exec(), 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 1422 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 1757 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 1428 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 1492 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(), libpqsrv_exec_params(), PQexecParams(), send_cancellable_query_impl(), 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 1633 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 1673 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 partial-result mode */
         conn->partialResMode = false;
         conn->singleRowMode = false;
         conn->maxChunkSize = 0;
     }
  
     /* ready to send command message */
     return true;
 }

References pg_conn::asyncStatus, pg_conn::cmd_queue_head, conn, CONNECTION_OK, libpq_append_conn_error(), pg_conn::maxChunkSize, pg_conn::partialResMode, 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 2589 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().

◆ PQsetChunkedRowsMode()

int PQsetChunkedRowsMode	(	PGconn *	conn,
		int	chunkSize
	)

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

 {
     if (chunkSize > 0 && canChangeResultMode(conn))
     {
         conn->partialResMode = true;
         conn->singleRowMode = false;
         conn->maxChunkSize = chunkSize;
         return 1;
     }
     else
         return 0;
 }

References canChangeResultMode(), conn, pg_conn::maxChunkSize, pg_conn::partialResMode, and pg_conn::singleRowMode.

Referenced by ExecQueryAndProcessResults(), and test_singlerowmode().

◆ PQsetnonblocking()

int PQsetnonblocking	(	PGconn *	conn,
		int	arg
	)

Definition at line 3944 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 (conn->cmd_queue_head == NULL)
         pqClearConnErrorState(conn);
  
     /* if we are going from blocking to non-blocking flush here */
     if (pqFlush(conn))
         return -1;
  
     conn->nonblocking = barg;
  
     return 0;
 }

References arg, pg_conn::cmd_queue_head, conn, CONNECTION_BAD, pg_conn::nonblocking, pqClearConnErrorState, pqFlush(), pg_conn::status, and true.

Referenced by test_cancel(), test_pipelined_insert(), and test_uniqviol().

◆ PQsetResultAttrs()

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

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

 {
     int         i;
  
     /* Fail if argument is NULL or OOM_result */
     if (!res || (const PGresult *) res == &OOM_result)
         return false;
  
     /* If attrs already exist, they cannot be overwritten. */
     if (res->numAttributes > 0)
         return false;
  
     /* ignore no-op request */
     if (numAttributes <= 0 || !attDescs)
         return true;
  
     res->attDescs = (PGresAttDesc *)
         PQresultAlloc(res, numAttributes * sizeof(PGresAttDesc));
  
     if (!res->attDescs)
         return false;
  
     res->numAttributes = numAttributes;
     memcpy(res->attDescs, attDescs, numAttributes * sizeof(PGresAttDesc));
  
     /* deep-copy the attribute names, and determine format */
     res->binary = 1;
     for (i = 0; i < res->numAttributes; i++)
     {
         if (res->attDescs[i].name)
             res->attDescs[i].name = pqResultStrdup(res, res->attDescs[i].name);
         else
             res->attDescs[i].name = res->null_field;
  
         if (!res->attDescs[i].name)
             return false;
  
         if (res->attDescs[i].format == 0)
             res->binary = 0;
     }
  
     return true;
 }

References pg_result::attDescs, pg_result::binary, pgresAttDesc::format, i, pgresAttDesc::name, pg_result::null_field, pg_result::numAttributes, OOM_result, PQresultAlloc(), pqResultStrdup(), and res.

Referenced by PQcopyResult().

◆ pqSetResultError()

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

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

 {
     char       *msg;
  
     if (!res)
         return;
  
     /*
      * We handle two OOM scenarios here.  The errorMessage buffer might be
      * marked "broken" due to having previously failed to allocate enough
      * memory for the message, or it might be fine but pqResultStrdup fails
      * and returns NULL.  In either case, just make res->errMsg point directly
      * at a constant "out of memory" string.
      */
     if (!PQExpBufferBroken(errorMessage))
         msg = pqResultStrdup(res, errorMessage->data + offset);
     else
         msg = NULL;
     if (msg)
         res->errMsg = msg;
     else
         res->errMsg = libpq_gettext("out of memory\n");
 }

References PQExpBufferData::data, pg_result::errMsg, libpq_gettext, PQExpBufferBroken, pqResultStrdup(), and res.

Referenced by pqGetErrorNotice3(), PQmakeEmptyPGresult(), and pqPrepareAsyncResult().

◆ PQsetSingleRowMode()

int PQsetSingleRowMode ( PGconn * conn )

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

 {
     if (canChangeResultMode(conn))
     {
         conn->partialResMode = true;
         conn->singleRowMode = true;
         conn->maxChunkSize = 1;
         return 1;
     }
     else
         return 0;
 }

References canChangeResultMode(), conn, pg_conn::maxChunkSize, pg_conn::partialResMode, and pg_conn::singleRowMode.

Referenced by process_queued_fetch_requests(), storeQueryResult(), test_pipeline_abort(), and test_singlerowmode().

◆ PQsetvalue()

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

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

 {
     PGresAttValue *attval;
     const char *errmsg = NULL;
  
     /* Fail if argument is NULL or OOM_result */
     if (!res || (const PGresult *) res == &OOM_result)
         return false;
  
     /* Invalid field_num? */
     if (!check_field_number(res, field_num))
         return false;
  
     /* Invalid tup_num, must be <= ntups */
     if (tup_num < 0 || tup_num > res->ntups)
     {
         pqInternalNotice(&res->noticeHooks,
                          "row number %d is out of range 0..%d",
                          tup_num, res->ntups);
         return false;
     }
  
     /* need to allocate a new tuple? */
     if (tup_num == res->ntups)
     {
         PGresAttValue *tup;
         int         i;
  
         tup = (PGresAttValue *)
             pqResultAlloc(res, res->numAttributes * sizeof(PGresAttValue),
                           true);
  
         if (!tup)
             goto fail;
  
         /* initialize each column to NULL */
         for (i = 0; i < res->numAttributes; i++)
         {
             tup[i].len = NULL_LEN;
             tup[i].value = res->null_field;
         }
  
         /* add it to the array */
         if (!pqAddTuple(res, tup, &errmsg))
             goto fail;
     }
  
     attval = &res->tuples[tup_num][field_num];
  
     /* treat either NULL_LEN or NULL value pointer as a NULL field */
     if (len == NULL_LEN || value == NULL)
     {
         attval->len = NULL_LEN;
         attval->value = res->null_field;
     }
     else if (len <= 0)
     {
         attval->len = 0;
         attval->value = res->null_field;
     }
     else
     {
         attval->value = (char *) pqResultAlloc(res, len + 1, true);
         if (!attval->value)
             goto fail;
         attval->len = len;
         memcpy(attval->value, value, len);
         attval->value[len] = '\0';
     }
  
     return true;
  
     /*
      * Report failure via pqInternalNotice.  If preceding code didn't provide
      * an error message, assume "out of memory" was meant.
      */
 fail:
     if (!errmsg)
         errmsg = libpq_gettext("out of memory");
     pqInternalNotice(&res->noticeHooks, "%s", errmsg);
  
     return false;
 }

References check_field_number(), errmsg(), i, pgresAttValue::len, len, libpq_gettext, pg_result::noticeHooks, pg_result::ntups, pg_result::null_field, NULL_LEN, pg_result::numAttributes, OOM_result, pqAddTuple(), pqInternalNotice(), pqResultAlloc(), res, pg_result::tuples, value, and pgresAttValue::value.

Referenced by PQcopyResult().

◆ PQunescapeBytea()

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

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

 {
     size_t      strtextlen,
                 buflen;
     unsigned char *buffer,
                *tmpbuf;
     size_t      i,
                 j;
  
     if (strtext == NULL)
         return NULL;
  
     strtextlen = strlen((const char *) strtext);
  
     if (strtext[0] == '\\' && strtext[1] == 'x')
     {
         const unsigned char *s;
         unsigned char *p;
  
         buflen = (strtextlen - 2) / 2;
         /* Avoid unportable malloc(0) */
         buffer = (unsigned char *) malloc(buflen > 0 ? buflen : 1);
         if (buffer == NULL)
             return NULL;
  
         s = strtext + 2;
         p = buffer;
         while (*s)
         {
             char        v1,
                         v2;
  
             /*
              * Bad input is silently ignored.  Note that this includes
              * whitespace between hex pairs, which is allowed by byteain.
              */
             v1 = get_hex(*s++);
             if (!*s || v1 == (char) -1)
                 continue;
             v2 = get_hex(*s++);
             if (v2 != (char) -1)
                 *p++ = (v1 << 4) | v2;
         }
  
         buflen = p - buffer;
     }
     else
     {
         /*
          * Length of input is max length of output, but add one to avoid
          * unportable malloc(0) if input is zero-length.
          */
         buffer = (unsigned char *) malloc(strtextlen + 1);
         if (buffer == NULL)
             return NULL;
  
         for (i = j = 0; i < strtextlen;)
         {
             switch (strtext[i])
             {
                 case '\\':
                     i++;
                     if (strtext[i] == '\\')
                         buffer[j++] = strtext[i++];
                     else
                     {
                         if ((ISFIRSTOCTDIGIT(strtext[i])) &&
                             (ISOCTDIGIT(strtext[i + 1])) &&
                             (ISOCTDIGIT(strtext[i + 2])))
                         {
                             int         byte;
  
                             byte = OCTVAL(strtext[i++]);
                             byte = (byte << 3) + OCTVAL(strtext[i++]);
                             byte = (byte << 3) + OCTVAL(strtext[i++]);
                             buffer[j++] = byte;
                         }
                     }
  
                     /*
                      * Note: if we see '\' followed by something that isn't a
                      * recognized escape sequence, we loop around having done
                      * nothing except advance i.  Therefore the something will
                      * be emitted as ordinary data on the next cycle. Corner
                      * case: '\' at end of string will just be discarded.
                      */
                     break;
  
                 default:
                     buffer[j++] = strtext[i++];
                     break;
             }
         }
         buflen = j;             /* buflen is the length of the dequoted data */
     }
  
     /* Shrink the buffer to be no larger than necessary */
     /* +1 avoids unportable behavior when buflen==0 */
     tmpbuf = realloc(buffer, buflen + 1);
  
     /* It would only be a very brain-dead realloc that could fail, but... */
     if (!tmpbuf)
     {
         free(buffer);
         return NULL;
     }
  
     *retbuflen = buflen;
     return tmpbuf;
 }

References free, get_hex(), i, ISFIRSTOCTDIGIT, ISOCTDIGIT, j, malloc, OCTVAL, realloc, and tmpbuf.

Variable Documentation

◆ hexlookup

const int8 hexlookup[128]

static

Initial value:

= {
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
}

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

Referenced by get_hex().

◆ hextbl

const char hextbl[] = "0123456789abcdef"

static

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

Referenced by PQescapeByteaInternal().

◆ OOM_result

const PGresult OOM_result

static

Initial value:

= {
    .resultStatus = PGRES_FATAL_ERROR,
    .client_encoding = PG_SQL_ASCII,
    .errMsg = "out of memory\n",
}

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

Referenced by PQclear(), pqPrepareAsyncResult(), PQresultAlloc(), PQsetResultAttrs(), and PQsetvalue().

◆ pgresStatus

char* const pgresStatus[]

Initial value:

= {
    "PGRES_EMPTY_QUERY",
    "PGRES_COMMAND_OK",
    "PGRES_TUPLES_OK",
    "PGRES_COPY_OUT",
    "PGRES_COPY_IN",
    "PGRES_BAD_RESPONSE",
    "PGRES_NONFATAL_ERROR",
    "PGRES_FATAL_ERROR",
    "PGRES_COPY_BOTH",
    "PGRES_SINGLE_TUPLE",
    "PGRES_PIPELINE_SYNC",
    "PGRES_PIPELINE_ABORTED",
    "PGRES_TUPLES_CHUNK"
}

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

Referenced by PQresStatus().

◆ static_client_encoding

int static_client_encoding = PG_SQL_ASCII

static

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

Referenced by PQescapeString(), and pqSaveParameterStatus().

◆ static_std_strings

bool static_std_strings = false

static

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

Referenced by PQescapeBytea(), PQescapeString(), and pqSaveParameterStatus().

Macros

Functions

Variables

Macro Definition Documentation

◆ ISFIRSTOCTDIGIT

◆ ISOCTDIGIT

◆ OCTVAL

◆ PGRESULT_ALIGN_BOUNDARY

◆ PGRESULT_BLOCK_OVERHEAD

◆ PGRESULT_DATA_BLOCKSIZE

◆ PGRESULT_SEP_ALLOC_THRESHOLD

Function Documentation

◆ canChangeResultMode()

◆ 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()