#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)

int	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 bool	add_size_overflow (size_t s1, size_t s2, size_t *dst)

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 4620 of file fe-exec.c.

◆ ISOCTDIGIT

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

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

◆ OCTVAL

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

Definition at line 4622 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

◆ add_size_overflow()

static bool add_size_overflow	(	size_t	s1,
		size_t	s2,
		size_t *	dst
	)

static

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

{
    size_t      result;
 
    result = s1 + s2;
    if (result < s1 || result < s2)
        return true;
 
    *dst = result;
    return false;
}

References s1, and s2.

Referenced by PQescapeByteaInternal(), and PQescapeInternal().

◆ canChangeResultMode()

static bool canChangeResultMode ( PGconn * conn )

static

Definition at line 1941 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 3526 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, and pqInternalNotice().

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 3564 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, and pqInternalNotice().

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 3541 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, and pqInternalNotice().

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 4445 of file fe-exec.c.

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

References hexlookup.

Referenced by PQunescapeBytea().

◆ getCopyResult()

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

static

Definition at line 2240 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 2036 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 998 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, pg_result::tupArrSize, and pg_result::tuples.

Referenced by pqRowProcessor(), and PQsetvalue().

◆ pqAllocCmdQueueEntry()

static PGcmdQueueEntry * pqAllocCmdQueueEntry ( PGconn * conn )

static

Definition at line 1322 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 1355 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 3513 of file fe-exec.c.

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

References pg_result::binary.

Referenced by HandleCopyResult().

◆ PQclear()

void PQclear ( PGresult * res )

Definition at line 726 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, 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 784 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 2555 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 2537 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 3768 of file fe-exec.c.

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

References pg_result::cmdStatus.

◆ PQcmdTuples()

char * PQcmdTuples ( PGresult * res )

Definition at line 3838 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, and pqInternalNotice().

◆ pqCommandQueueAdvance()

void pqCommandQueueAdvance	(	PGconn *	conn,
		bool	isReadyForQuery,
		bool	gotSync
	)

Definition at line 3158 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 2000 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(), consume_query_cancel_impl(), CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), do_sql_command_end(), ecpg_process_output(), libpqrcv_receive(), libpqsrv_get_result(), main(), pgfdw_cancel_query_end(), pgfdw_exec_cleanup_query_end(), pgfdw_get_cleanup_result(), postgresForeignAsyncNotify(), PQconnectPoll(), PrintNotifications(), process_slot(), 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 2490 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 2471 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 2965 of file fe-exec.c.

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

References conn, and pqEndcopy3().

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

◆ PQenterPipelineMode()

int PQenterPipelineMode ( PGconn * conn )

Definition at line 3058 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 ExecQueryAndProcessResults(), 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 4612 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 4596 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 4472 of file fe-exec.c.

{
    const unsigned char *vp;
    unsigned char *rp;
    unsigned char *result;
    size_t      i;
    size_t      len;
    const size_t bslash_len = (std_strings ? 1 : 2);
 
    /*
     * Calculate the escaped length, watching for overflow as we do with
     * PQescapeInternal(). The following code relies on a small constant
     * bslash_len so that small additions and multiplications don't need their
     * own overflow checks.
     *
     * Start with the empty string, which has 1 char ('\0').
     */
    len = 1;
 
    if (use_hex)
    {
        /* We prepend "\x" and double each input character. */
        if (add_size_overflow(len, bslash_len + 1, &len) ||
            add_size_overflow(len, from_length, &len) ||
            add_size_overflow(len, from_length, &len))
            goto overflow;
    }
    else
    {
        vp = from;
        for (i = from_length; i > 0; i--, vp++)
        {
            if (*vp < 0x20 || *vp > 0x7e)
            {
                if (add_size_overflow(len, bslash_len + 3, &len))   /* octal "\ooo" */
                    goto overflow;
            }
            else if (*vp == '\'')
            {
                if (add_size_overflow(len, 2, &len))    /* double each quote */
                    goto overflow;
            }
            else if (*vp == '\\')
            {
                if (add_size_overflow(len, bslash_len * 2, &len))   /* double each backslash */
                    goto overflow;
            }
            else
            {
                if (add_size_overflow(len, 1, &len))
                    goto overflow;
            }
        }
    }
 
    *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;
 
overflow:
    if (conn)
        libpq_append_conn_error(conn,
                                "escaped bytea size exceeds the maximum allowed (%zu)",
                                SIZE_MAX);
    return NULL;
}

References add_size_overflow(), 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 4425 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(), escape_identifier(), 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 4251 of file fe-exec.c.

{
    const char *s;
    char       *result;
    char       *rp;
    size_t      num_quotes = 0; /* single or double, depending on as_ident */
    size_t      num_backslashes = 0;
    size_t      input_len = strnlen(str, len);
    size_t      result_size;
    char        quote_char = as_ident ? '"' : '\'';
    bool        validated_mb = false;
 
    /* 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 and for invalidly
     * encoded data.
     */
    s = str;
    for (size_t remaining = input_len; remaining > 0; remaining--, 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_or_incomplete(conn->client_encoding,
                                                      s, remaining);
 
            if (charlen > remaining)
            {
                /* Multibyte character overruns allowable length. */
                libpq_append_conn_error(conn, "incomplete multibyte character");
                return NULL;
            }
 
            /*
             * If we haven't already, check that multibyte characters are
             * valid. It's important to verify that as invalid multi-byte
             * characters could e.g. be used to "skip" over quote characters,
             * e.g. when parsing character-by-character.
             *
             * We check validity once, for the whole remainder of the string,
             * when we first encounter any multi-byte character. Some
             * encodings have optimized implementations for longer strings.
             */
            if (!validated_mb)
            {
                if (pg_encoding_verifymbstr(conn->client_encoding, s, remaining)
                    != remaining)
                {
                    libpq_append_conn_error(conn, "invalid multibyte character");
                    return NULL;
                }
                validated_mb = true;
            }
 
            /* Adjust s, bearing in mind that for loop will increment it. */
            s += charlen - 1;
            remaining -= charlen - 1;
        }
    }
 
    /*
     * Allocate output buffer. Protect against overflow, in case the caller
     * has allocated a large fraction of the available size_t.
     */
    if (add_size_overflow(input_len, num_quotes, &result_size) ||
        add_size_overflow(result_size, 3, &result_size))    /* two quotes plus a NUL */
        goto overflow;
 
    if (!as_ident && num_backslashes > 0)
    {
        if (add_size_overflow(result_size, num_backslashes, &result_size) ||
            add_size_overflow(result_size, 2, &result_size))    /* for " E" prefix */
            goto overflow;
    }
 
    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
    {
        s = str;
        for (size_t remaining = input_len; remaining > 0; remaining--, 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;
                    remaining--;
                    ++s;        /* for loop will provide the final increment */
                }
            }
        }
    }
 
    /* Closing quote and terminating NUL. */
    *rp++ = quote_char;
    *rp = '\0';
 
    return result;
 
overflow:
    libpq_append_conn_error(conn,
                            "escaped string size exceeds the maximum allowed (%zu)",
                            SIZE_MAX);
    return NULL;
}

References add_size_overflow(), pg_conn::client_encoding, pg_conn::cmd_queue_head, conn, i, IS_HIGHBIT_SET, len, libpq_append_conn_error(), malloc, pg_encoding_mblen(), pg_encoding_mblen_or_incomplete(), pg_encoding_verifymbstr(), pqClearConnErrorState, remaining, str, and strnlen().

Referenced by PQescapeIdentifier(), and PQescapeLiteral().

◆ PQescapeLiteral()

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

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

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

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

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

◆ PQescapeString()

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

Definition at line 4215 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 escape_string(), 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 4193 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(), do_lo_import(), and escape_string_conn().

◆ 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 4087 of file fe-exec.c.

{
    const char *source = from;
    char       *target = to;
    size_t      remaining = strnlen(from, length);
    bool        already_complained = false;
 
    if (error)
        *error = 0;
 
    while (remaining > 0)
    {
        char        c = *source;
        int         charlen;
        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 */
        charlen = pg_encoding_mblen_or_incomplete(encoding,
                                                  source, remaining);
 
        if (remaining < charlen ||
            pg_encoding_verifymbchar(encoding, source, charlen) == -1)
        {
            /*
             * Multibyte character is invalid.  It's important to verify that
             * as invalid multibyte characters could e.g. be used to "skip"
             * over quote characters, e.g. when parsing
             * character-by-character.
             *
             * Report an error if possible, and replace the character's first
             * byte with an invalid sequence. The invalid sequence ensures
             * that the escaped string will trigger an error on the
             * server-side, even if we can't directly report an error here.
             *
             * This isn't *that* crucial when we can report an error to the
             * caller; but if we can't or the caller ignores it, the caller
             * will use this string unmodified and it needs to be safe for
             * parsing.
             *
             * We know there's enough space for the invalid sequence because
             * the "to" buffer needs to be at least 2 * length + 1 long, and
             * at worst we're replacing a single input byte with two invalid
             * bytes.
             *
             * It would be a bit faster to verify the whole string the first
             * time we encounter a set highbit, but this way we can replace
             * just the invalid data, which probably makes it easier for users
             * to find the invalidly encoded portion of a larger string.
             */
            if (error)
                *error = 1;
            if (conn && !already_complained)
            {
                if (remaining < charlen)
                    libpq_append_conn_error(conn, "incomplete multibyte character");
                else
                    libpq_append_conn_error(conn, "invalid multibyte character");
                /* Issue a complaint only once per string */
                already_complained = true;
            }
 
            pg_encoding_set_invalid(encoding, target);
            target += 2;
 
            /*
             * Handle the following bytes as if this byte didn't exist. That's
             * safer in case the subsequent bytes contain important characters
             * for the caller (e.g. '>' in html).
             */
            source++;
            remaining--;
        }
        else
        {
            /* Copy the character */
            for (i = 0; i < charlen; i++)
            {
                *target++ = *source++;
                remaining--;
            }
        }
    }
 
    /* Write the terminating NUL character. */
    *target = '\0';
 
    return target - to;
}

References conn, encoding, error(), i, IS_HIGHBIT_SET, libpq_append_conn_error(), pg_encoding_mblen_or_incomplete(), pg_encoding_set_invalid(), pg_encoding_verifymbchar(), remaining, source, SQL_STR_DOUBLE, and strnlen().

Referenced by PQescapeString(), and PQescapeStringConn().

◆ PQexec()

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

Definition at line 2278 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(), _printTableAccessMethodNoStorage(), _selectOutputSchema(), _selectTableAccessMethod(), _selectTablespace(), check_and_drop_existing_subscriptions(), check_and_drop_publications(), 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_existing_subscription(), drop_failover_replication_slots(), drop_publication(), drop_replication_slot(), DropReplicationSlot(), ecpg_autostart_transaction(), ecpg_execute(), ecpg_is_type_an_array(), ECPGsetcommit(), ECPGtrans(), enable_subscription(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), generate_object_name(), get_create_object_cmd(), get_primary_sysid(), get_publisher_databases(), 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(), setup_publisher(), sql_conn(), sql_exec(), StreamLogicalLog(), test_disallowed_in_pipeline(), test_pipeline_abort(), test_prepared(), test_transaction(), test_uniqviol(), tryExecuteStatement(), and vacuumlo().

◆ PQexecFinish()

static PGresult * PQexecFinish ( PGconn * conn )

static

Definition at line 2426 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 2292 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(), get_table_relkind(), 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 2339 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 2360 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 3089 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(), ExecQueryAndProcessResults(), 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 3724 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(), and pgresAttDesc::format.

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

◆ PQflush()

int PQflush ( PGconn * conn )

Definition at line 4016 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(), ExecQueryAndProcessResults(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), libpqrcv_send(), prepareToTerminate(), ProcessWALDataMsg(), sendFeedback(), test_nosync(), test_pipelined_insert(), and test_uniqviol().

◆ PQfmod()

int PQfmod	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3757 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, and check_field_number().

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 2996 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 3583 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(), and pgresAttDesc::name.

◆ PQfnumber()

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

Definition at line 3605 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, and pg_tolower().

Referenced by append_depends_on_extension(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), check_for_connection_status(), check_for_pg_role_prefix(), check_new_cluster_replication_slots(), collectComments(), collectSecLabels(), describeOneTableDetails(), dropRoles(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpFunc(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRelationStats_dumper(), dumpRoleMembership(), dumpRoles(), dumpTableSchema(), dumpTSConfig(), dumpUserMappings(), get_db_infos(), get_subscription_info(), 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(), getSubscriptionRelations(), getSubscriptions(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), old_9_6_invalidate_hash_indexes(), process_data_type_check(), process_extension_updates(), process_incompat_polymorphics(), process_inconsistent_notnull(), process_isn_and_int8_passing_mismatch(), process_old_cluster_logical_slot_infos(), process_old_sub_state_check(), process_rel_infos(), process_unicode_update(), process_user_defined_encoding_conversions(), process_user_defined_postfix_ops(), process_with_oids_check(), processExtensionTables(), set_frozenxids(), and show_binary_results().

◆ PQfreemem()

void PQfreemem ( void * ptr )

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

{
    free(ptr);
}

References free.

Referenced by check_and_drop_existing_subscriptions(), create_logical_replication_slot(), create_publication(), create_subscription(), dblink_get_notify(), DescribeQuery(), do_connect(), drop_publication(), drop_replication_slot(), dumpTableData_copy(), ecpg_process_output(), enable_subscription(), escape_identifier(), escape_literal(), exec_command_errverbose(), get_base_conninfo(), handleCopyOut(), HandleCopyStream(), 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(), set_replication_progress(), StreamLogicalLog(), stringlist_to_identifierstr(), try_complete_step(), and vacuumlo().

◆ PQfreeNotify()

void PQfreeNotify ( PGnotify * notify )

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

{
    PQfreemem(notify);
}

References PQfreemem().

◆ PQfsize()

int PQfsize	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3746 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(), and pgresAttDesc::typlen.

Referenced by ecpg_build_compat_sqlda(), and ECPGget_desc().

◆ PQftable()

Oid PQftable	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3702 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, and pgresAttDesc::tableid.

◆ PQftablecol()

int PQftablecol	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3713 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(), and pgresAttDesc::columnid.

◆ PQftype()

Oid PQftype	(	const PGresult *	res,
		int	field_num
	)

Definition at line 3735 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, 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 2832 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 3917 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, and pg_result::tuples.

◆ PQgetlength()

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

Definition at line 3903 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, and pg_result::tuples.

◆ PQgetline()

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

Definition at line 2870 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 2917 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 2078 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(), pg_conn::result, pg_result::resultStatus, and pg_conn::write_failed.

Referenced by PQexecFinish(), and PQexecStart().

◆ PQgetvalue()

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

Definition at line 3892 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(), pg_result::tuples, and pgresAttValue::value.

◆ pqInternalNotice()

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

Definition at line 943 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, 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(), sprintf, 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 2047 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(), consume_query_cancel_impl(), dblink_is_busy(), libpqsrv_get_result(), pgfdw_get_cleanup_result(), PQconnectPoll(), pqEndcopy3(), process_slot(), 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 3999 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 4008 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 3505 of file fe-exec.c.

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

References pg_result::numAttributes.

◆ PQnotifies()

PGnotify * PQnotifies ( PGconn * conn )

Definition at line 2683 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 3931 of file fe-exec.c.

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

References pg_result::numParameters.

◆ PQntuples()

int PQntuples ( const PGresult * res )

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

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

References pg_result::ntups.

◆ PQoidStatus()

char * PQoidStatus ( const PGresult * res )

Definition at line 3781 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, and len.

◆ PQoidValue()

Oid PQoidValue ( const PGresult * res )

Definition at line 3809 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, and InvalidOid.

Referenced by ecpg_process_output(), and PrintQueryStatus().

◆ PQparamtype()

Oid PQparamtype	(	const PGresult *	res,
		int	param_num
	)

Definition at line 3942 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, and pgresParamDesc::typid.

◆ pqPipelineFlush()

static int pqPipelineFlush ( PGconn * conn )

static

Definition at line 4032 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 3196 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 3288 of file fe-exec.c.

{
    return pqPipelineSyncInternal(conn, true);
}

References conn, and pqPipelineSyncInternal().

Referenced by discardUntilSync(), ExecQueryAndProcessResults(), 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 3310 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 2322 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 856 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(), 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 2711 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 2765 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 ProcessWALDataMsg().

◆ PQputline()

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

Definition at line 2934 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 2944 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 1402 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 3435 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(), confirm_result_status_impl(), consume_null_result_impl(), process_result(), test_pipeline_abort(), test_pipelined_insert(), test_prepared(), 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, and pqResultAlloc().

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;
 
        /* Don't wrap around with overly large requests. */
        if (nBytes > SIZE_MAX - PGRESULT_BLOCK_OVERHEAD)
            return NULL;
 
        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, 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 3482 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, and pgMessageField::next.

◆ PQresultErrorMessage()

char * PQresultErrorMessage ( const PGresult * res )

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

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

References pg_result::errMsg.

◆ PQresultMemorySize()

size_t PQresultMemorySize ( const PGresult * res )

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

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

References pg_result::memorySize.

◆ PQresultStatus()

ExecStatusType PQresultStatus ( const PGresult * res )

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

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

References PGRES_FATAL_ERROR, and pg_result::resultStatus.

◆ pqResultStrdup()

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

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

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

References pqResultAlloc(), and str.

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

◆ PQresultVerboseErrorMessage()

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

Definition at line 3451 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, pg_result::resultStatus, and termPQExpBuffer().

Referenced by exec_command_errverbose().

◆ pqRowProcessor()

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

Definition at line 1222 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, (size_t) 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(), 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 808 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(), handleFatalError(), pqFunctionCall3(), pqGetNegotiateProtocolVersion3(), PQgetResult(), pqParseInput3(), pqPipelineProcessQueue(), and pqSaveWriteError().

◆ pqSaveMessageField()

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

Definition at line 1065 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(), and value.

Referenced by pqGetErrorNotice3(), and pqInternalNotice().

◆ pqSaveParameterStatus()

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

Definition at line 1090 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;
    }
    else
    {
        /* out of memory */
        return 0;
    }
 
    /*
     * 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);
    }
 
    return 1;
}

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 825 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 2585 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 2572 of file fe-exec.c.

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

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

Referenced by ExecQueryAndProcessResults(), and test_prepared().

◆ PQsendDescribePortal()

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

Definition at line 2520 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 2507 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 3387 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 ExecQueryAndProcessResults(), test_nosync(), test_pipeline_idle(), test_singlerowmode(), and test_uniqviol().

◆ PQsendPipelineSync()

int PQsendPipelineSync ( PGconn * conn )

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

{
    return pqPipelineSyncInternal(conn, false);
}

References conn, and pqPipelineSyncInternal().

Referenced by ExecQueryAndProcessResults(), executeMetaCommand(), and test_multi_pipelines().

◆ PQsendPrepare()

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

Definition at line 1552 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 ExecQueryAndProcessResults(), PQprepare(), prepare_foreign_modify(), test_pipelined_insert(), test_prepared(), and test_transaction().

◆ PQsendQuery()

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

Definition at line 1432 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(), libpqsrv_exec(), pgfdw_exec_cleanup_query_begin(), pgfdw_exec_query(), pgfdw_finish_pre_commit_cleanup(), PQexec(), process_slot(), 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 1438 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 1773 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 1444 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 1508 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 1649 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 ExecQueryAndProcessResults(), 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 1689 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 2605 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, "unrecognized message type \"%c\"", command);
        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 1981 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 3960 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(), and pqResultStrdup().

Referenced by PQcopyResult().

◆ pqSetResultError()

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

Definition at line 697 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, and pqResultStrdup().

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

◆ PQsetSingleRowMode()

int PQsetSingleRowMode ( PGconn * conn )

Definition at line 1964 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, (size_t) 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(), pg_result::tuples, value, and pgresAttValue::value.

Referenced by PQcopyResult().

◆ PQunescapeBytea()

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

Definition at line 4637 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 4433 of file fe-exec.c.

Referenced by get_hex().

◆ hextbl

const char hextbl[] = "0123456789abcdef"

static

Definition at line 4431 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

◆ add_size_overflow()

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