#include <stdio.h>
#include "postgres_ext.h"

Include dependency graph for libpq-fe.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	pgNotify

struct	_PQprintOpt

struct	_PQconninfoOption

struct	PQArgBlock

struct	pgresAttDesc

Macros
#define	PG_COPYRES_ATTRS 0x01

#define	PG_COPYRES_TUPLES 0x02 /* Implies PG_COPYRES_ATTRS */

#define	PG_COPYRES_EVENTS 0x04

#define	PG_COPYRES_NOTICEHOOKS 0x08

#define	PQsetdb(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME) PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, NULL, NULL)

#define	PQfreeNotify(ptr) PQfreemem(ptr)

#define	PQnoPasswordSupplied "fe_sendauth: no password supplied\n"

Typedefs
typedef struct pg_conn	PGconn

typedef struct pg_result	PGresult

typedef struct pg_cancel	PGcancel

typedef struct pgNotify	PGnotify

typedef void(*	PQnoticeReceiver )(void arg, const PGresult res)

typedef void(*	PQnoticeProcessor )(void arg, const char message)

typedef char	pqbool

typedef struct _PQprintOpt	PQprintOpt

typedef struct _PQconninfoOption	PQconninfoOption

typedef struct pgresAttDesc	PGresAttDesc

typedef void(*	pgthreadlock_t )(int acquire)

Enumerations
enum	ConnStatusType { CONNECTION_OK, CONNECTION_BAD, CONNECTION_STARTED, CONNECTION_MADE, CONNECTION_AWAITING_RESPONSE, CONNECTION_AUTH_OK, CONNECTION_SETENV, CONNECTION_SSL_STARTUP, CONNECTION_NEEDED, CONNECTION_CHECK_WRITABLE, CONNECTION_CONSUME }

enum	PostgresPollingStatusType { PGRES_POLLING_FAILED = 0, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PGRES_POLLING_OK, PGRES_POLLING_ACTIVE }

enum	ExecStatusType { PGRES_EMPTY_QUERY = 0, 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 }

enum	PGTransactionStatusType { PQTRANS_IDLE, PQTRANS_ACTIVE, PQTRANS_INTRANS, PQTRANS_INERROR, PQTRANS_UNKNOWN }

enum	PGVerbosity { PQERRORS_TERSE, PQERRORS_DEFAULT, PQERRORS_VERBOSE }

enum	PGContextVisibility { PQSHOW_CONTEXT_NEVER, PQSHOW_CONTEXT_ERRORS, PQSHOW_CONTEXT_ALWAYS }

enum	PGPing { PQPING_OK, PQPING_REJECT, PQPING_NO_RESPONSE, PQPING_NO_ATTEMPT }

Functions
PGconn *	PQconnectStart (const char *conninfo)

PGconn *	PQconnectStartParams (const char const keywords, const char const values, int expand_dbname)

PostgresPollingStatusType	PQconnectPoll (PGconn *conn)

PGconn *	PQconnectdb (const char *conninfo)

PGconn *	PQconnectdbParams (const char const keywords, const char const values, int expand_dbname)

PGconn *	PQsetdbLogin (const char pghost, const char pgport, const char pgoptions, const char pgtty, const char dbName, const char login, const char *pwd)

void	PQfinish (PGconn *conn)

PQconninfoOption *	PQconndefaults (void)

PQconninfoOption *	PQconninfoParse (const char conninfo, char *errmsg)

PQconninfoOption *	PQconninfo (PGconn *conn)

void	PQconninfoFree (PQconninfoOption *connOptions)

int	PQresetStart (PGconn *conn)

PostgresPollingStatusType	PQresetPoll (PGconn *conn)

void	PQreset (PGconn *conn)

PGcancel *	PQgetCancel (PGconn *conn)

void	PQfreeCancel (PGcancel *cancel)

int	PQcancel (PGcancel cancel, char errbuf, int errbufsize)

int	PQrequestCancel (PGconn *conn)

char *	PQdb (const PGconn *conn)

char *	PQuser (const PGconn *conn)

char *	PQpass (const PGconn *conn)

char *	PQhost (const PGconn *conn)

char *	PQport (const PGconn *conn)

char *	PQtty (const PGconn *conn)

char *	PQoptions (const PGconn *conn)

ConnStatusType	PQstatus (const PGconn *conn)

PGTransactionStatusType	PQtransactionStatus (const PGconn *conn)

const char *	PQparameterStatus (const PGconn conn, const char paramName)

int	PQprotocolVersion (const PGconn *conn)

int	PQserverVersion (const PGconn *conn)

char *	PQerrorMessage (const PGconn *conn)

int	PQsocket (const PGconn *conn)

int	PQbackendPID (const PGconn *conn)

int	PQconnectionNeedsPassword (const PGconn *conn)

int	PQconnectionUsedPassword (const PGconn *conn)

int	PQclientEncoding (const PGconn *conn)

int	PQsetClientEncoding (PGconn conn, const char encoding)

int	PQsslInUse (PGconn *conn)

void *	PQsslStruct (PGconn conn, const char struct_name)

const char *	PQsslAttribute (PGconn conn, const char attribute_name)

const char const	PQsslAttributeNames (PGconn *conn)

void *	PQgetssl (PGconn *conn)

void	PQinitSSL (int do_init)

void	PQinitOpenSSL (int do_ssl, int do_crypto)

PGVerbosity	PQsetErrorVerbosity (PGconn *conn, PGVerbosity verbosity)

PGContextVisibility	PQsetErrorContextVisibility (PGconn *conn, PGContextVisibility show_context)

void	PQtrace (PGconn conn, FILE debug_port)

void	PQuntrace (PGconn *conn)

PQnoticeReceiver	PQsetNoticeReceiver (PGconn conn, PQnoticeReceiver proc, void arg)

PQnoticeProcessor	PQsetNoticeProcessor (PGconn conn, PQnoticeProcessor proc, void arg)

pgthreadlock_t	PQregisterThreadLock (pgthreadlock_t newhandler)

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)

int	PQsendQuery (PGconn conn, const char query)

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

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

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

int	PQsetSingleRowMode (PGconn *conn)

PGresult *	PQgetResult (PGconn *conn)

int	PQisBusy (PGconn *conn)

int	PQconsumeInput (PGconn *conn)

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 string, int length)

int	PQputline (PGconn conn, const char string)

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

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

int	PQendcopy (PGconn *conn)

int	PQsetnonblocking (PGconn *conn, int arg)

int	PQisnonblocking (const PGconn *conn)

int	PQisthreadsafe (void)

PGPing	PQping (const char *conninfo)

PGPing	PQpingParams (const char const keywords, const char const values, int expand_dbname)

int	PQflush (PGconn *conn)

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

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)

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)

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)

void	PQclear (PGresult *res)

void	PQfreemem (void *ptr)

PGresult *	PQmakeEmptyPGresult (PGconn *conn, ExecStatusType status)

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

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

void *	PQresultAlloc (PGresult *res, size_t nBytes)

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

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

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

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

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

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

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

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

void	PQprint (FILE fout, const PGresult res, const PQprintOpt *ps)

void	PQdisplayTuples (const PGresult res, FILE fp, int fillAlign, const char *fieldSep, int printHeader, int quiet)

void	PQprintTuples (const PGresult res, FILE fout, int printAttName, int terseOutput, int width)

int	lo_open (PGconn *conn, Oid lobjId, int mode)

int	lo_close (PGconn *conn, int fd)

int	lo_read (PGconn conn, int fd, char buf, size_t len)

int	lo_write (PGconn conn, int fd, const char buf, size_t len)

int	lo_lseek (PGconn *conn, int fd, int offset, int whence)

pg_int64	lo_lseek64 (PGconn *conn, int fd, pg_int64 offset, int whence)

Oid	lo_creat (PGconn *conn, int mode)

Oid	lo_create (PGconn *conn, Oid lobjId)

int	lo_tell (PGconn *conn, int fd)

pg_int64	lo_tell64 (PGconn *conn, int fd)

int	lo_truncate (PGconn *conn, int fd, size_t len)

int	lo_truncate64 (PGconn *conn, int fd, pg_int64 len)

int	lo_unlink (PGconn *conn, Oid lobjId)

Oid	lo_import (PGconn conn, const char filename)

Oid	lo_import_with_oid (PGconn conn, const char filename, Oid lobjId)

int	lo_export (PGconn conn, Oid lobjId, const char filename)

int	PQlibVersion (void)

int	PQmblen (const char *s, int encoding)

int	PQdsplen (const char *s, int encoding)

int	PQenv2encoding (void)

char *	PQencryptPassword (const char passwd, const char user)

char *	PQencryptPasswordConn (PGconn conn, const char passwd, const char user, const char algorithm)

int	pg_char_to_encoding (const char *name)

const char *	pg_encoding_to_char (int encoding)

int	pg_valid_server_encoding_id (int encoding)

Macro Definition Documentation

#define PG_COPYRES_ATTRS 0x01

Definition at line 34 of file libpq-fe.h.

Referenced by PQcopyResult(), and pqRowProcessor().

#define PG_COPYRES_EVENTS 0x04

Definition at line 36 of file libpq-fe.h.

Referenced by PQcopyResult(), and pqRowProcessor().

#define PG_COPYRES_NOTICEHOOKS 0x08

Definition at line 37 of file libpq-fe.h.

Referenced by PQcopyResult(), and pqRowProcessor().

#define PG_COPYRES_TUPLES 0x02 /* Implies PG_COPYRES_ATTRS */

Definition at line 35 of file libpq-fe.h.

Referenced by PQcopyResult().

#define PQfreeNotify ( ptr ) PQfreemem(ptr)

Definition at line 508 of file libpq-fe.h.

#define PQnoPasswordSupplied "fe_sendauth: no password supplied\n"

Definition at line 512 of file libpq-fe.h.

Referenced by pg_fe_sendauth(), and pg_SASL_init().

#define PQsetdb	(	M_PGHOST,
		M_PGPORT,
		M_PGOPT,
		M_PGTTY,
		M_DBNAME
	)	PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, NULL, NULL)

Definition at line 269 of file libpq-fe.h.

Referenced by main().

Typedef Documentation

typedef struct pg_cancel PGcancel

Definition at line 153 of file libpq-fe.h.

typedef struct pg_conn PGconn

Definition at line 140 of file libpq-fe.h.

typedef struct pgNotify PGnotify

typedef struct pgresAttDesc PGresAttDesc

typedef struct pg_result PGresult

Definition at line 147 of file libpq-fe.h.

typedef void(* pgthreadlock_t)(int acquire)

Definition at line 374 of file libpq-fe.h.

typedef char pqbool

Definition at line 175 of file libpq-fe.h.

typedef struct _PQconninfoOption PQconninfoOption

typedef void(* PQnoticeProcessor)(void *arg, const char *message)

Definition at line 172 of file libpq-fe.h.

typedef void(* PQnoticeReceiver)(void *arg, const PGresult *res)

Definition at line 171 of file libpq-fe.h.

typedef struct _PQprintOpt PQprintOpt

Enumeration Type Documentation

enum ConnStatusType

Enumerator
CONNECTION_OK
CONNECTION_BAD
CONNECTION_STARTED
CONNECTION_MADE
CONNECTION_AWAITING_RESPONSE
CONNECTION_AUTH_OK
CONNECTION_SETENV
CONNECTION_SSL_STARTUP
CONNECTION_NEEDED
CONNECTION_CHECK_WRITABLE
CONNECTION_CONSUME

Definition at line 47 of file libpq-fe.h.

 {
     CONNECTION_OK,
     CONNECTION_BAD,
     /* Non-blocking mode only below here */
 
     /*
      * The existence of these should never be relied upon - they should only
      * be used for user feedback or similar purposes.
      */
     CONNECTION_STARTED,         /* Waiting for connection to be made.  */
     CONNECTION_MADE,            /* Connection OK; waiting to send.     */
     CONNECTION_AWAITING_RESPONSE,   /* Waiting for a response from the
                                      * postmaster.        */
     CONNECTION_AUTH_OK,         /* Received authentication; waiting for
                                  * backend startup. */
     CONNECTION_SETENV,          /* Negotiating environment. */
     CONNECTION_SSL_STARTUP,     /* Negotiating SSL. */
     CONNECTION_NEEDED,          /* Internal state: connect() needed */
     CONNECTION_CHECK_WRITABLE,  /* Check if we could make a writable
                                  * connection. */
     CONNECTION_CONSUME          /* Wait for any pending message and consume
                                  * them. */
 } ConnStatusType;

enum ExecStatusType

Enumerator
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

Definition at line 82 of file libpq-fe.h.

 {
     PGRES_EMPTY_QUERY = 0,      /* empty query string was executed */
     PGRES_COMMAND_OK,           /* a query command that doesn't return
                                  * anything was executed properly by the
                                  * backend */
     PGRES_TUPLES_OK,            /* a query command that returns tuples was
                                  * executed properly by the backend, PGresult
                                  * contains the result tuples */
     PGRES_COPY_OUT,             /* Copy Out data transfer in progress */
     PGRES_COPY_IN,              /* Copy In data transfer in progress */
     PGRES_BAD_RESPONSE,         /* an unexpected response was recv'd from the
                                  * backend */
     PGRES_NONFATAL_ERROR,       /* notice or warning message */
     PGRES_FATAL_ERROR,          /* query failed */
     PGRES_COPY_BOTH,            /* Copy In/Out data transfer in progress */
     PGRES_SINGLE_TUPLE          /* single tuple from larger resultset */
 } ExecStatusType;

enum PGContextVisibility

Enumerator
PQSHOW_CONTEXT_NEVER
PQSHOW_CONTEXT_ERRORS
PQSHOW_CONTEXT_ALWAYS

Definition at line 117 of file libpq-fe.h.

 {
     PQSHOW_CONTEXT_NEVER,       /* never show CONTEXT field */
     PQSHOW_CONTEXT_ERRORS,      /* show CONTEXT for errors only (default) */
     PQSHOW_CONTEXT_ALWAYS       /* always show CONTEXT field */
 } PGContextVisibility;

enum PGPing

Enumerator
PQPING_OK
PQPING_REJECT
PQPING_NO_RESPONSE
PQPING_NO_ATTEMPT

Definition at line 129 of file libpq-fe.h.

 {
     PQPING_OK,                  /* server is accepting connections */
     PQPING_REJECT,              /* server is alive but rejecting connections */
     PQPING_NO_RESPONSE,         /* could not establish connection */
     PQPING_NO_ATTEMPT           /* connection not attempted (bad params) */
 } PGPing;

enum PGTransactionStatusType

Enumerator
PQTRANS_IDLE
PQTRANS_ACTIVE
PQTRANS_INTRANS
PQTRANS_INERROR
PQTRANS_UNKNOWN

Definition at line 101 of file libpq-fe.h.

 {
     PQTRANS_IDLE,               /* connection idle */
     PQTRANS_ACTIVE,             /* command in progress */
     PQTRANS_INTRANS,            /* idle, within transaction block */
     PQTRANS_INERROR,            /* idle, within failed transaction */
     PQTRANS_UNKNOWN             /* cannot determine status */
 } PGTransactionStatusType;

enum PGVerbosity

Enumerator
PQERRORS_TERSE
PQERRORS_DEFAULT
PQERRORS_VERBOSE

Definition at line 110 of file libpq-fe.h.

 {
     PQERRORS_TERSE,             /* single-line error messages */
     PQERRORS_DEFAULT,           /* recommended style */
     PQERRORS_VERBOSE            /* all the facts, ma'am */
 } PGVerbosity;

enum PostgresPollingStatusType

Enumerator
PGRES_POLLING_FAILED
PGRES_POLLING_READING
PGRES_POLLING_WRITING
PGRES_POLLING_OK
PGRES_POLLING_ACTIVE

Definition at line 72 of file libpq-fe.h.

 {
     PGRES_POLLING_FAILED = 0,
     PGRES_POLLING_READING,      /* These two indicate that one may    */
     PGRES_POLLING_WRITING,      /* use select before polling again.   */
     PGRES_POLLING_OK,
     PGRES_POLLING_ACTIVE        /* unused; keep for awhile for backwards
                                  * compatibility */
 } PostgresPollingStatusType;

Function Documentation

int lo_close	(	PGconn *	conn,
		int	fd
	)

Definition at line 100 of file fe-lobj.c.

References fd(), pgLobjfuncs::fn_lo_close, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by dumpBlobs(), EndRestoreBlob(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), and pickout().

 {
     PQArgBlock  argv[1];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
     res = PQfn(conn, conn->lobjfuncs->fn_lo_close,
                &retval, &result_len, 1, argv, 1);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

Oid lo_creat	(	PGconn *	conn,
		int	mode
	)

Definition at line 466 of file fe-lobj.c.

References pgLobjfuncs::fn_lo_creat, PQArgBlock::integer, InvalidOid, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by importFile(), and lo_import_internal().

 {
     PQArgBlock  argv[1];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return InvalidOid;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = mode;
     res = PQfn(conn, conn->lobjfuncs->fn_lo_creat,
                &retval, &result_len, 1, argv, 1);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return (Oid) retval;
     }
     else
     {
         PQclear(res);
         return InvalidOid;
     }
 }

Oid lo_create	(	PGconn *	conn,
		Oid	lobjId
	)

Definition at line 505 of file fe-lobj.c.

References pg_conn::errorMessage, pgLobjfuncs::fn_lo_create, PQArgBlock::integer, InvalidOid, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), printfPQExpBuffer(), and PQArgBlock::u.

Referenced by lo_import_internal(), and StartRestoreBlob().

 {
     PQArgBlock  argv[1];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return InvalidOid;
     }
 
     /* Must check this on-the-fly because it's not there pre-8.1 */
     if (conn->lobjfuncs->fn_lo_create == 0)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("cannot determine OID of function lo_create\n"));
         return InvalidOid;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = lobjId;
     res = PQfn(conn, conn->lobjfuncs->fn_lo_create,
                &retval, &result_len, 1, argv, 1);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return (Oid) retval;
     }
     else
     {
         PQclear(res);
         return InvalidOid;
     }
 }

int lo_export	(	PGconn *	conn,
		Oid	lobjId,
		const char *	filename
	)

Definition at line 785 of file fe-lobj.c.

References buf, close, pg_conn::errorMessage, fd(), INV_READ, libpq_gettext, LO_BUFSIZE, lo_close(), lo_open(), lo_read(), PG_BINARY, pqStrerror(), printfPQExpBuffer(), result, and write.

Referenced by do_lo_export(), and main().

 {
     int         result = 1;
     int         fd;
     int         nbytes,
                 tmp;
     char        buf[LO_BUFSIZE];
     int         lobj;
     char        sebuf[256];
 
     /*
      * open the large object.
      */
     lobj = lo_open(conn, lobjId, INV_READ);
     if (lobj == -1)
     {
         /* we assume lo_open() already set a suitable error message */
         return -1;
     }
 
     /*
      * create the file to be written to
      */
     fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, 0666);
     if (fd < 0)
     {
         /* We must do lo_close before setting the errorMessage */
         int         save_errno = errno;
 
         (void) lo_close(conn, lobj);
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("could not open file \"%s\": %s\n"),
                           filename,
                           pqStrerror(save_errno, sebuf, sizeof(sebuf)));
         return -1;
     }
 
     /*
      * read in from the large object and write to the file
      */
     while ((nbytes = lo_read(conn, lobj, buf, LO_BUFSIZE)) > 0)
     {
         tmp = write(fd, buf, nbytes);
         if (tmp != nbytes)
         {
             /* We must do lo_close before setting the errorMessage */
             int         save_errno = errno;
 
             (void) lo_close(conn, lobj);
             (void) close(fd);
             printfPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("could not write to file \"%s\": %s\n"),
                               filename,
                               pqStrerror(save_errno, sebuf, sizeof(sebuf)));
             return -1;
         }
     }
 
     /*
      * If lo_read() failed, we are now in an aborted transaction so there's no
      * need for lo_close(); furthermore, if we tried it we'd overwrite the
      * useful error result with a useless one. So skip lo_close() if we got a
      * failure result.
      */
     if (nbytes < 0 ||
         lo_close(conn, lobj) != 0)
     {
         /* assume lo_read() or lo_close() left a suitable error message */
         result = -1;
     }
 
     /* if we already failed, don't overwrite that msg with a close error */
     if (close(fd) && result >= 0)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("could not write to file \"%s\": %s\n"),
                           filename, pqStrerror(errno, sebuf, sizeof(sebuf)));
         result = -1;
     }
 
     return result;
 }

Oid lo_import	(	PGconn *	conn,
		const char *	filename
	)

Definition at line 669 of file fe-lobj.c.

References InvalidOid, and lo_import_internal().

Referenced by do_lo_import(), and main().

 {
     return lo_import_internal(conn, filename, InvalidOid);
 }

Oid lo_import_with_oid	(	PGconn *	conn,
		const char *	filename,
		Oid	lobjId
	)

Definition at line 684 of file fe-lobj.c.

References lo_import_internal().

 {
     return lo_import_internal(conn, filename, lobjId);
 }

int lo_lseek	(	PGconn *	conn,
		int	fd,
		int	offset,
		int	whence
	)

Definition at line 366 of file fe-lobj.c.

References fd(), pgLobjfuncs::fn_lo_lseek, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by overwrite(), and pickout().

 {
     PQArgBlock  argv[3];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     argv[1].isint = 1;
     argv[1].len = 4;
     argv[1].u.integer = offset;
 
     argv[2].isint = 1;
     argv[2].len = 4;
     argv[2].u.integer = whence;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek,
                &retval, &result_len, 1, argv, 3);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

pg_int64 lo_lseek64	(	PGconn *	conn,
		int	fd,
		pg_int64	offset,
		int	whence
	)

Definition at line 410 of file fe-lobj.c.

References pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_lseek64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_hton64(), lo_initialize(), lo_ntoh64(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), printfPQExpBuffer(), PQArgBlock::ptr, and PQArgBlock::u.

Referenced by overwrite(), and pickout().

 {
     PQArgBlock  argv[3];
     PGresult   *res;
     pg_int64    retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     if (conn->lobjfuncs->fn_lo_lseek64 == 0)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("cannot determine OID of function lo_lseek64\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     offset = lo_hton64(offset);
     argv[1].isint = 0;
     argv[1].len = 8;
     argv[1].u.ptr = (int *) &offset;
 
     argv[2].isint = 1;
     argv[2].len = 4;
     argv[2].u.integer = whence;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek64,
                (void *) &retval, &result_len, 0, argv, 3);
     if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
     {
         PQclear(res);
         return lo_ntoh64(retval);
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int lo_open	(	PGconn *	conn,
		Oid	lobjId,
		int	mode
	)

Definition at line 58 of file fe-lobj.c.

References fd(), pgLobjfuncs::fn_lo_open, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by dumpBlobs(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), pickout(), and StartRestoreBlob().

 {
     int         fd;
     int         result_len;
     PQArgBlock  argv[2];
     PGresult   *res;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = lobjId;
 
     argv[1].isint = 1;
     argv[1].len = 4;
     argv[1].u.integer = mode;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_open, &fd, &result_len, 1, argv, 2);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return fd;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int lo_read	(	PGconn *	conn,
		int	fd,
		char *	buf,
		size_t	len
	)

Definition at line 259 of file fe-lobj.c.

References pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_read, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), printfPQExpBuffer(), and PQArgBlock::u.

Referenced by lo_export().

 {
     PQArgBlock  argv[2];
     PGresult   *res;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     /*
      * Long ago, somebody thought it'd be a good idea to declare this function
      * as taking size_t ... but the underlying backend function only accepts a
      * signed int32 length.  So throw error if the given value overflows
      * int32.
      */
     if (len > (size_t) INT_MAX)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("argument of lo_read exceeds integer range\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     argv[1].isint = 1;
     argv[1].len = 4;
     argv[1].u.integer = (int) len;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_read,
                (void *) buf, &result_len, 0, argv, 2);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return result_len;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int lo_tell	(	PGconn *	conn,
		int	fd
	)

Definition at line 549 of file fe-lobj.c.

References fd(), pgLobjfuncs::fn_lo_tell, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

 {
     int         retval;
     PQArgBlock  argv[1];
     PGresult   *res;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_tell,
                &retval, &result_len, 1, argv, 1);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

pg_int64 lo_tell64	(	PGconn *	conn,
		int	fd
	)

Definition at line 585 of file fe-lobj.c.

References pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_tell64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_initialize(), lo_ntoh64(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), printfPQExpBuffer(), and PQArgBlock::u.

Referenced by pickout().

 {
     pg_int64    retval;
     PQArgBlock  argv[1];
     PGresult   *res;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     if (conn->lobjfuncs->fn_lo_tell64 == 0)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("cannot determine OID of function lo_tell64\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_tell64,
                (void *) &retval, &result_len, 0, argv, 1);
     if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
     {
         PQclear(res);
         return lo_ntoh64(retval);
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int lo_truncate	(	PGconn *	conn,
		int	fd,
		size_t	len
	)

Definition at line 138 of file fe-lobj.c.

References pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_truncate, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), printfPQExpBuffer(), and PQArgBlock::u.

 {
     PQArgBlock  argv[2];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     /* Must check this on-the-fly because it's not there pre-8.3 */
     if (conn->lobjfuncs->fn_lo_truncate == 0)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("cannot determine OID of function lo_truncate\n"));
         return -1;
     }
 
     /*
      * Long ago, somebody thought it'd be a good idea to declare this function
      * as taking size_t ... but the underlying backend function only accepts a
      * signed int32 length.  So throw error if the given value overflows
      * int32.  (A possible alternative is to automatically redirect the call
      * to lo_truncate64; but if the caller wanted to rely on that backend
      * function being available, he could have called lo_truncate64 for
      * himself.)
      */
     if (len > (size_t) INT_MAX)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("argument of lo_truncate exceeds integer range\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     argv[1].isint = 1;
     argv[1].len = 4;
     argv[1].u.integer = (int) len;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate,
                &retval, &result_len, 1, argv, 2);
 
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int lo_truncate64	(	PGconn *	conn,
		int	fd,
		pg_int64	len
	)

Definition at line 206 of file fe-lobj.c.

References pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_truncate64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_hton64(), lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), printfPQExpBuffer(), PQArgBlock::ptr, and PQArgBlock::u.

Referenced by my_truncate().

 {
     PQArgBlock  argv[2];
     PGresult   *res;
     int         retval;
     int         result_len;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     if (conn->lobjfuncs->fn_lo_truncate64 == 0)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("cannot determine OID of function lo_truncate64\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     len = lo_hton64(len);
     argv[1].isint = 0;
     argv[1].len = 8;
     argv[1].u.ptr = (int *) &len;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate64,
                &retval, &result_len, 1, argv, 2);
 
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int lo_unlink	(	PGconn *	conn,
		Oid	lobjId
	)

Definition at line 629 of file fe-lobj.c.

References pgLobjfuncs::fn_lo_unlink, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by do_lo_unlink(), and vacuumlo().

 {
     PQArgBlock  argv[1];
     PGresult   *res;
     int         result_len;
     int         retval;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = lobjId;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_unlink,
                &retval, &result_len, 1, argv, 1);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int lo_write	(	PGconn *	conn,
		int	fd,
		const char *	buf,
		size_t	len
	)

Definition at line 313 of file fe-lobj.c.

References pg_conn::errorMessage, fd(), pgLobjfuncs::fn_lo_write, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_gettext, lo_initialize(), pg_conn::lobjfuncs, NULL, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), printfPQExpBuffer(), PQArgBlock::ptr, and PQArgBlock::u.

Referenced by lo_import_internal().

 {
     PQArgBlock  argv[2];
     PGresult   *res;
     int         result_len;
     int         retval;
 
     if (conn == NULL || conn->lobjfuncs == NULL)
     {
         if (lo_initialize(conn) < 0)
             return -1;
     }
 
     /*
      * Long ago, somebody thought it'd be a good idea to declare this function
      * as taking size_t ... but the underlying backend function only accepts a
      * signed int32 length.  So throw error if the given value overflows
      * int32.
      */
     if (len > (size_t) INT_MAX)
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("argument of lo_write exceeds integer range\n"));
         return -1;
     }
 
     argv[0].isint = 1;
     argv[0].len = 4;
     argv[0].u.integer = fd;
 
     argv[1].isint = 0;
     argv[1].len = (int) len;
     argv[1].u.ptr = (int *) buf;
 
     res = PQfn(conn, conn->lobjfuncs->fn_lo_write,
                &retval, &result_len, 1, argv, 2);
     if (PQresultStatus(res) == PGRES_COMMAND_OK)
     {
         PQclear(res);
         return retval;
     }
     else
     {
         PQclear(res);
         return -1;
     }
 }

int pg_char_to_encoding ( const char * name )

Definition at line 551 of file encnames.c.

References clean_encoding_name(), ereport, errcode(), errmsg(), ERROR, lengthof, NAMEDATALEN, NULL, pg_encname_tbl, and result.

Referenced by CreateConversionCommand(), length_in_encoding(), main(), PG_char_to_encoding(), pg_convert(), pg_get_utf8_id(), pg_valid_client_encoding(), pg_valid_server_encoding(), PQenv2encoding(), pqSaveParameterStatus(), ProcessCopyOptions(), processEncodingEntry(), and to_ascii_encname().

 {
     unsigned int nel = lengthof(pg_encname_tbl);
     const pg_encname *base = pg_encname_tbl,
                *last = base + nel - 1,
                *position;
     int         result;
     char        buff[NAMEDATALEN],
                *key;
 
     if (name == NULL || *name == '\0')
         return -1;
 
     if (strlen(name) >= NAMEDATALEN)
     {
 #ifdef FRONTEND
         fprintf(stderr, "encoding name too long\n");
         return -1;
 #else
         ereport(ERROR,
                 (errcode(ERRCODE_NAME_TOO_LONG),
                  errmsg("encoding name too long")));
 #endif
     }
     key = clean_encoding_name(name, buff);
 
     while (last >= base)
     {
         position = base + ((last - base) >> 1);
         result = key[0] - position->name[0];
 
         if (result == 0)
         {
             result = strcmp(key, position->name);
             if (result == 0)
                 return position->encoding;
         }
         if (result < 0)
             last = position - 1;
         else
             base = position + 1;
     }
     return -1;
 }

const char* pg_encoding_to_char ( int encoding )

Definition at line 607 of file encnames.c.

References Assert, encoding, pg_enc2name::encoding, pg_enc2name::name, and PG_VALID_ENCODING.

Referenced by _doSetFixedOutputState(), check_client_encoding(), check_encoding_locale_matches(), check_locale_and_encoding(), check_locale_encoding(), CollationCreate(), connectOptions2(), ConversionCreate(), createdb(), dumpEncoding(), exec_command_encoding(), get_encoding_name_for_icu(), main(), pg_do_encoding_conversion(), PG_encoding_to_char(), pg_to_ascii(), PQsetClientEncoding(), SendQuery(), setup_locale_encoding(), setupDumpWorker(), and SyncVariables().

 {
     if (PG_VALID_ENCODING(encoding))
     {
         const pg_enc2name *p = &pg_enc2name_tbl[encoding];
 
         Assert(encoding == p->encoding);
         return p->name;
     }
     return "";
 }

int pg_valid_server_encoding_id ( int encoding )

Definition at line 515 of file encnames.c.

References PG_VALID_BE_ENCODING.

Referenced by setup_locale_encoding().

 {
     return PG_VALID_BE_ENCODING(encoding);
 }

int PQbackendPID ( const PGconn * conn )

Definition at line 6123 of file fe-connect.c.

References pg_conn::be_pid, CONNECTION_OK, and pg_conn::status.

Referenced by get_prompt(), and LogStreamerMain().

 {
     if (!conn || conn->status != CONNECTION_OK)
         return 0;
     return conn->be_pid;
 }

int PQbinaryTuples ( const PGresult * res )

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

References pg_result::binary.

Referenced by ProcessResult().

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

int PQcancel	(	PGcancel *	cancel,
		char *	errbuf,
		int	errbufsize
	)

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

References pg_cancel::be_key, pg_cancel::be_pid, FALSE, internal_cancel(), pg_cancel::raddr, and strlcpy().

Referenced by dblink_cancel_query(), DisconnectDatabase(), handle_sigint(), pgfdw_cancel_query(), ShutdownWorkersHard(), sigTermHandler(), and try_complete_step().

 {
     if (!cancel)
     {
         strlcpy(errbuf, "PQcancel() -- no cancel object supplied", errbufsize);
         return FALSE;
     }
 
     return internal_cancel(&cancel->raddr, cancel->be_pid, cancel->be_key,
                            errbuf, errbufsize);
 }

void PQclear ( PGresult * res )

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

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

Referenced by _check_database_version(), _doSetSessionAuth(), _doSetWithOids(), _selectOutputSchema(), _selectTablespace(), add_tablespace_footer(), BaseBackup(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_rel_oid(), binary_upgrade_set_type_oids_by_type_oid(), buildMatViewRefreshDependencies(), buildShSecLabels(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_is_install_user(), check_loadable_libraries(), check_proper_datallowconn(), ClearOrSaveResult(), close_cursor(), cluster_all_databases(), convertTSFunction(), create_cursor(), CreateReplicationSlot(), createViewAsClause(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), dblink_res_error(), deallocate_one(), describeAccessMethods(), describeAggregates(), describeFunctions(), describeOneTableDetails(), describeOneTSConfig(), describeOneTSParser(), describeOperators(), describePublications(), describeRoles(), describeSubscriptions(), describeTableDetails(), describeTablespaces(), describeTypes(), descriptor_free(), discard_response(), do_lo_import(), do_lo_list(), do_sql_command(), doCustom(), dropDBs(), DropReplicationSlot(), dropRoles(), dropTablespaces(), dumpAgg(), dumpBaseType(), dumpBlobs(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConversion(), dumpCreateDB(), dumpDatabase(), dumpDatabaseConfig(), dumpDatabases(), dumpDbRoleConfig(), dumpDomain(), dumpEnumType(), dumpFunc(), dumpGroups(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSequence(), dumpSequenceData(), dumpTable(), dumpTableData_copy(), dumpTableData_insert(), dumpTableSchema(), dumpTablespaces(), dumpTSConfig(), dumpTSDictionary(), dumpUserConfig(), dumpUserMappings(), ecpg_autostart_transaction(), ecpg_check_PQresult(), ecpg_is_type_an_array(), ecpg_process_output(), ECPGdescribe(), ECPGsetcommit(), ECPGtrans(), EndDBCopyMode(), exec_command_password(), ExecQueryUsingCursor(), executeCommand(), executeMaintenanceCommand(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlStatement(), executeStatement(), expand_schema_name_patterns(), expand_table_name_patterns(), fail_lo_xact(), fetch_more_data(), findLastBuiltinOid_V71(), finish_lo_xact(), get_create_object_cmd(), get_db_infos(), get_language_name(), get_loadable_libraries(), get_rel_infos(), get_remote_estimate(), get_returning_data(), get_synchronized_snapshot(), get_tablespace_paths(), getAccessMethods(), getAggregates(), getBlobs(), getCasts(), getCollations(), getConstraints(), getConversions(), getCopyStart(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFormattedTypeName(), getFuncs(), getIndexes(), getInherits(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getParamDescriptions(), getPolicies(), getProcLangs(), getPublications(), getPublicationTables(), GetQueryResult(), getRowDescriptions(), getRules(), getSubscriptions(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), handleCopyIn(), HandleEndOfCopyStream(), init(), libpq_executeFileMap(), libpqConnect(), libpqGetFile(), libpqProcessFileList(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_PQexec(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_startstreaming(), listAllDbs(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listOneExtensionContents(), listPublications(), listSchemas(), listTables(), listTSConfigs(), listTSConfigsVerbose(), listTSDictionaries(), listTSParsers(), listTSParsersVerbose(), listTSTemplates(), listUserMappings(), lo_close(), lo_creat(), lo_create(), lo_initialize(), lo_lseek(), lo_lseek64(), lo_open(), lo_read(), lo_tell(), lo_tell64(), lo_truncate(), lo_truncate64(), lo_unlink(), lo_write(), lockTableForWorker(), lookup_object_oid(), main(), materializeQueryResult(), materializeResult(), new_9_0_populate_pg_largeobject_metadata(), objectDescription(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), permissionsList(), pg_attribute_noreturn(), pgfdw_cancel_query(), pgfdw_exec_cleanup_query(), pgfdw_get_cleanup_result(), pgfdw_get_result(), pgfdw_report_error(), pgfdw_xact_callback(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresEndDirectModify(), postgresEndForeignModify(), postgresExecForeignDelete(), postgresExecForeignInsert(), postgresExecForeignUpdate(), postgresImportForeignSchema(), postgresReScanForeignScan(), pqClearAsyncResult(), PQconnectPoll(), PQcopyResult(), PQencryptPasswordConn(), pqEndcopy2(), pqEndcopy3(), PQexecFinish(), PQexecStart(), pqGetErrorNotice2(), pqGetErrorNotice3(), pqInternalNotice(), PQmakeEmptyPGresult(), pqRowProcessor(), PQsetClientEncoding(), pqSetenvPoll(), prepare_common(), prepare_foreign_modify(), processExtensionTables(), ProcessResult(), PSQLexecWatch(), receiveFileChunks(), ReceiveXlogStream(), reindex_all_databases(), run_permutation(), run_simple_query(), RunIdentifySystem(), sendCommand(), SendQuery(), set_frozenxids(), sql_exec(), start_lo_xact(), store_returning_result(), storeQueryResult(), StreamLogicalLog(), try_complete_step(), tryExecuteStatement(), vacuum_all_databases(), vacuum_one_database(), and vacuumlo().

 {
     PGresult_data *block;
     int         i;
 
     if (!res)
         return;
 
     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);
     }
 
     if (res->events)
         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 */
     if (res->tuples)
         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);
 }

int PQclientEncoding ( const PGconn * conn )

Definition at line 6157 of file fe-connect.c.

References pg_conn::client_encoding, CONNECTION_OK, and pg_conn::status.

Referenced by appendStringLiteralConn(), dblink_connect(), dblink_get_conn(), exec_command_encoding(), main(), processSQLNamePattern(), SendQuery(), setup_connection(), and SyncVariables().

 {
     if (!conn || conn->status != CONNECTION_OK)
         return -1;
     return conn->client_encoding;
 }

char* PQcmdStatus ( PGresult * res )

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

References pg_result::cmdStatus, and NULL.

Referenced by dblink_exec(), ecpg_process_output(), materializeQueryResult(), materializeResult(), PrintQueryResults(), PrintQueryStatus(), PSQLexecWatch(), and SendQuery().

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

char* PQcmdTuples ( PGresult * res )

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

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

Referenced by ecpg_process_output(), execute_dml_stmt(), postgresExecForeignDelete(), postgresExecForeignInsert(), and postgresExecForeignUpdate().

 {
     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)
         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 "";
 }

PQconninfoOption* PQconndefaults ( void )

Definition at line 1224 of file fe-connect.c.

References conninfo_add_defaults(), conninfo_init(), initPQExpBuffer(), NULL, PQconninfoFree(), PQExpBufferDataBroken, and termPQExpBuffer().

Referenced by check_pghost_envvar(), dblink_fdw_validator(), get_connect_string(), InitPgFdwOptions(), and main().

 {
     PQExpBufferData errorBuf;
     PQconninfoOption *connOptions;
 
     /* We don't actually report any errors here, but callees want a buffer */
     initPQExpBuffer(&errorBuf);
     if (PQExpBufferDataBroken(errorBuf))
         return NULL;            /* out of memory already :-( */
 
     connOptions = conninfo_init(&errorBuf);
     if (connOptions != NULL)
     {
         /* pass NULL errorBuf to ignore errors */
         if (!conninfo_add_defaults(connOptions, NULL))
         {
             PQconninfoFree(connOptions);
             connOptions = NULL;
         }
     }
 
     termPQExpBuffer(&errorBuf);
     return connOptions;
 }

PGconn* PQconnectdb ( const char * conninfo )

Definition at line 585 of file fe-connect.c.

References conn, connectDBComplete(), CONNECTION_BAD, PQconnectStart(), and pg_conn::status.

Referenced by dblink_connect(), dblink_get_conn(), get_db_conn(), libpqConnect(), and main().

 {
     PGconn     *conn = PQconnectStart(conninfo);
 
     if (conn && conn->status != CONNECTION_BAD)
         (void) connectDBComplete(conn);
 
     return conn;
 }

PGconn* PQconnectdbParams	(	const char const	keywords,
		const char const	values,
		int	expand_dbname
	)

Definition at line 529 of file fe-connect.c.

References conn, connectDBComplete(), CONNECTION_BAD, PQconnectStartParams(), and pg_conn::status.

Referenced by _connectDB(), connect_pg_server(), connectDatabase(), ConnectDatabase(), do_connect(), doConnect(), ECPGconnect(), GetConnection(), main(), sql_conn(), and vacuumlo().

 {
     PGconn     *conn = PQconnectStartParams(keywords, values, expand_dbname);
 
     if (conn && conn->status != CONNECTION_BAD)
         (void) connectDBComplete(conn);
 
     return conn;
 
 }

int PQconnectionNeedsPassword ( const PGconn * conn )

Definition at line 6131 of file fe-connect.c.

References NULL, password, pg_conn::password_needed, and PQpass().

Referenced by _connectDB(), connectDatabase(), ConnectDatabase(), do_connect(), doConnect(), GetConnection(), main(), sql_conn(), and vacuumlo().

 {
     char       *password;
 
     if (!conn)
         return false;
     password = PQpass(conn);
     if (conn->password_needed &&
         (password == NULL || password[0] == '\0'))
         return true;
     else
         return false;
 }

int PQconnectionUsedPassword ( const PGconn * conn )

Definition at line 6146 of file fe-connect.c.

References pg_conn::password_needed.

Referenced by _connectDB(), connect_pg_server(), ConnectDatabase(), and dblink_security_check().

 {
     if (!conn)
         return false;
     if (conn->password_needed)
         return true;
     else
         return false;
 }

PostgresPollingStatusType PQconnectPoll ( PGconn * conn )

Definition at line 1997 of file fe-connect.c.

References SockAddr::addr, pg_conn::addr_cur, pg_conn_host::addrlist, addrinfo::ai_addr, addrinfo::ai_addrlen, addrinfo::ai_family, addrinfo::ai_next, appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), pg_conn::appname, pg_conn::asyncStatus, AUTH_REQ_MD5, AUTH_REQ_OK, pg_conn::auth_req_received, CHT_HOST_ADDRESS, connect, connectFailureMessage(), CONNECTION_AUTH_OK, CONNECTION_AWAITING_RESPONSE, CONNECTION_BAD, CONNECTION_CHECK_WRITABLE, CONNECTION_CONSUME, CONNECTION_MADE, CONNECTION_NEEDED, CONNECTION_OK, CONNECTION_SETENV, CONNECTION_SSL_STARTUP, CONNECTION_STARTED, connectNoDelay(), pg_conn::connhost, PQExpBufferData::data, EINPROGRESS, EINTR, EnvironmentOptions, ERRCODE_APPNAME_UNKNOWN, pg_conn::errorMessage, EWOULDBLOCK, pg_conn::fbappname, free, getpeereid(), pg_conn_host::host, pg_conn_host::hostaddr, pg_conn::inCursor, pg_conn::inEnd, pg_conn::inStart, IS_AF_UNIX, pg_conn::laddr, PQExpBufferData::len, libpq_gettext, pg_conn::nconnhost, NEGOTIATE_SSL_CODE, pg_conn::next_eo, NULL, PG_DIAG_SQLSTATE, pg_fe_sendauth(), PG_PROTOCOL, PG_PROTOCOL_MAJOR, pg_set_noblock(), PGASYNC_BUSY, PGINVALID_SOCKET, pgpassfileWarning(), PGRES_FATAL_ERROR, PGRES_POLLING_FAILED, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PGRES_TUPLES_OK, pg_conn_host::port, pqBuildStartupPacket2(), pqBuildStartupPacket3(), pqCheckInBufferSpace(), PQclear(), PQconsumeInput(), pqDropConnection(), pqFlush(), pqGetc(), pqGetErrorNotice3(), pqGetInt(), pqGetpwuid(), PQgetResult(), pqGets_append(), PQgetvalue(), PQisBusy(), PQntuples(), pqPacketSend(), pqReadData(), PQresultErrorField(), PQresultStatus(), pqsecure_initialize(), pqsecure_open_client(), PQsendQuery(), pqSetenvPoll(), pqStrerror(), printfPQExpBuffer(), pg_conn::pversion, pg_conn::raddr, release_all_addrinfo(), pg_conn::requirepeer, restoreErrorMessage(), pg_result::resultStatus, SockAddr::salen, saveErrorMessage(), pg_conn::send_appname, sendTerminateConn(), pg_conn::setenv_state, SETENV_STATE_CLIENT_ENCODING_SEND, setKeepalivesCount(), setKeepalivesIdle(), setKeepalivesInterval(), pg_conn::sigpipe_flag, pg_conn::sigpipe_so, pg_conn::sock, SOCK_ERRNO, SOCK_STRERROR, socket, pg_conn::sslmode, pg_conn::status, STATUS_OK, pg_conn::target_session_attrs, termPQExpBuffer(), pg_conn_host::type, useKeepalives(), val, and pg_conn::whichhost.

Referenced by connectDBComplete(), connectDBStart(), libpqrcv_connect(), and PQresetPoll().

 {
     PGresult   *res;
     char        sebuf[256];
     int         optval;
     PQExpBufferData savedMessage;
 
     if (conn == NULL)
         return PGRES_POLLING_FAILED;
 
     /* Get the new data */
     switch (conn->status)
     {
             /*
              * We really shouldn't have been polled in these two cases, but we
              * can handle it.
              */
         case CONNECTION_BAD:
             return PGRES_POLLING_FAILED;
         case CONNECTION_OK:
             return PGRES_POLLING_OK;
 
             /* These are reading states */
         case CONNECTION_AWAITING_RESPONSE:
         case CONNECTION_AUTH_OK:
             {
                 /* Load waiting data */
                 int         n = pqReadData(conn);
 
                 if (n < 0)
                     goto error_return;
                 if (n == 0)
                     return PGRES_POLLING_READING;
 
                 break;
             }
 
             /* These are writing states, so we just proceed. */
         case CONNECTION_STARTED:
         case CONNECTION_MADE:
             break;
 
             /* We allow pqSetenvPoll to decide whether to proceed. */
         case CONNECTION_SETENV:
             break;
 
             /* Special cases: proceed without waiting. */
         case CONNECTION_SSL_STARTUP:
         case CONNECTION_NEEDED:
         case CONNECTION_CHECK_WRITABLE:
         case CONNECTION_CONSUME:
             break;
 
         default:
             appendPQExpBufferStr(&conn->errorMessage,
                                  libpq_gettext(
                                                "invalid connection state, "
                                                "probably indicative of memory corruption\n"
                                                ));
             goto error_return;
     }
 
 
 keep_going:                     /* We will come back to here until there is
                                  * nothing left to do. */
     switch (conn->status)
     {
         case CONNECTION_NEEDED:
             {
                 /*
                  * Try to initiate a connection to one of the addresses
                  * returned by pg_getaddrinfo_all().  conn->addr_cur is the
                  * next one to try. We fail when we run out of addresses.
                  */
                 for (;;)
                 {
                     struct addrinfo *addr_cur;
 
                     /*
                      * Advance to next possible host, if we've tried all of
                      * the addresses for the current host.
                      */
                     if (conn->addr_cur == NULL)
                     {
                         if (++conn->whichhost >= conn->nconnhost)
                         {
                             conn->whichhost = 0;
                             break;
                         }
                         conn->addr_cur =
                             conn->connhost[conn->whichhost].addrlist;
                     }
 
                     /* Remember current address for possible error msg */
                     addr_cur = conn->addr_cur;
                     memcpy(&conn->raddr.addr, addr_cur->ai_addr,
                            addr_cur->ai_addrlen);
                     conn->raddr.salen = addr_cur->ai_addrlen;
 
                     conn->sock = socket(addr_cur->ai_family, SOCK_STREAM, 0);
                     if (conn->sock == PGINVALID_SOCKET)
                     {
                         /*
                          * ignore socket() failure if we have more addresses
                          * to try
                          */
                         if (addr_cur->ai_next != NULL ||
                             conn->whichhost + 1 < conn->nconnhost)
                         {
                             conn->addr_cur = addr_cur->ai_next;
                             continue;
                         }
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not create socket: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         break;
                     }
 
                     /*
                      * Select socket options: no delay of outgoing data for
                      * TCP sockets, nonblock mode, close-on-exec. Fail if any
                      * of this fails.
                      */
                     if (!IS_AF_UNIX(addr_cur->ai_family))
                     {
                         if (!connectNoDelay(conn))
                         {
                             pqDropConnection(conn, true);
                             conn->addr_cur = addr_cur->ai_next;
                             continue;
                         }
                     }
                     if (!pg_set_noblock(conn->sock))
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not set socket to nonblocking mode: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         pqDropConnection(conn, true);
                         conn->addr_cur = addr_cur->ai_next;
                         continue;
                     }
 
 #ifdef F_SETFD
                     if (fcntl(conn->sock, F_SETFD, FD_CLOEXEC) == -1)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not set socket to close-on-exec mode: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         pqDropConnection(conn, true);
                         conn->addr_cur = addr_cur->ai_next;
                         continue;
                     }
 #endif                          /* F_SETFD */
 
                     if (!IS_AF_UNIX(addr_cur->ai_family))
                     {
 #ifndef WIN32
                         int         on = 1;
 #endif
                         int         usekeepalives = useKeepalives(conn);
                         int         err = 0;
 
                         if (usekeepalives < 0)
                         {
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("keepalives parameter must be an integer\n"));
                             err = 1;
                         }
                         else if (usekeepalives == 0)
                         {
                             /* Do nothing */
                         }
 #ifndef WIN32
                         else if (setsockopt(conn->sock,
                                             SOL_SOCKET, SO_KEEPALIVE,
                                             (char *) &on, sizeof(on)) < 0)
                         {
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("setsockopt(%s) failed: %s\n"),
                                               "SO_KEEPALIVE",
                                               SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                             err = 1;
                         }
                         else if (!setKeepalivesIdle(conn)
                                  || !setKeepalivesInterval(conn)
                                  || !setKeepalivesCount(conn))
                             err = 1;
 #else                           /* WIN32 */
 #ifdef SIO_KEEPALIVE_VALS
                         else if (!setKeepalivesWin32(conn))
                             err = 1;
 #endif                          /* SIO_KEEPALIVE_VALS */
 #endif                          /* WIN32 */
 
                         if (err)
                         {
                             pqDropConnection(conn, true);
                             conn->addr_cur = addr_cur->ai_next;
                             continue;
                         }
                     }
 
                     /*----------
                      * We have three methods of blocking SIGPIPE during
                      * send() calls to this socket:
                      *
                      *  - setsockopt(sock, SO_NOSIGPIPE)
                      *  - send(sock, ..., MSG_NOSIGNAL)
                      *  - setting the signal mask to SIG_IGN during send()
                      *
                      * The third method requires three syscalls per send,
                      * so we prefer either of the first two, but they are
                      * less portable.  The state is tracked in the following
                      * members of PGconn:
                      *
                      * conn->sigpipe_so     - we have set up SO_NOSIGPIPE
                      * conn->sigpipe_flag   - we're specifying MSG_NOSIGNAL
                      *
                      * If we can use SO_NOSIGPIPE, then set sigpipe_so here
                      * and we're done.  Otherwise, set sigpipe_flag so that
                      * we will try MSG_NOSIGNAL on sends.  If we get an error
                      * with MSG_NOSIGNAL, we'll clear that flag and revert to
                      * signal masking.
                      *----------
                      */
                     conn->sigpipe_so = false;
 #ifdef MSG_NOSIGNAL
                     conn->sigpipe_flag = true;
 #else
                     conn->sigpipe_flag = false;
 #endif                          /* MSG_NOSIGNAL */
 
 #ifdef SO_NOSIGPIPE
                     optval = 1;
                     if (setsockopt(conn->sock, SOL_SOCKET, SO_NOSIGPIPE,
                                    (char *) &optval, sizeof(optval)) == 0)
                     {
                         conn->sigpipe_so = true;
                         conn->sigpipe_flag = false;
                     }
 #endif                          /* SO_NOSIGPIPE */
 
                     /*
                      * Start/make connection.  This should not block, since we
                      * are in nonblock mode.  If it does, well, too bad.
                      */
                     if (connect(conn->sock, addr_cur->ai_addr,
                                 addr_cur->ai_addrlen) < 0)
                     {
                         if (SOCK_ERRNO == EINPROGRESS ||
 #ifdef WIN32
                             SOCK_ERRNO == EWOULDBLOCK ||
 #endif
                             SOCK_ERRNO == EINTR)
                         {
                             /*
                              * This is fine - we're in non-blocking mode, and
                              * the connection is in progress.  Tell caller to
                              * wait for write-ready on socket.
                              */
                             conn->status = CONNECTION_STARTED;
                             return PGRES_POLLING_WRITING;
                         }
                         /* otherwise, trouble */
                     }
                     else
                     {
                         /*
                          * Hm, we're connected already --- seems the "nonblock
                          * connection" wasn't.  Advance the state machine and
                          * go do the next stuff.
                          */
                         conn->status = CONNECTION_STARTED;
                         goto keep_going;
                     }
 
                     /*
                      * This connection failed --- set up error report, then
                      * close socket (do it this way in case close() affects
                      * the value of errno...).  We will ignore the connect()
                      * failure and keep going if there are more addresses.
                      */
                     connectFailureMessage(conn, SOCK_ERRNO);
                     pqDropConnection(conn, true);
 
                     /*
                      * Try the next address, if any.
                      */
                     conn->addr_cur = addr_cur->ai_next;
                 }               /* loop over addresses */
 
                 /*
                  * Oops, no more addresses.  An appropriate error message is
                  * already set up, so just set the right status.
                  */
                 goto error_return;
             }
 
         case CONNECTION_STARTED:
             {
                 ACCEPT_TYPE_ARG3 optlen = sizeof(optval);
 
                 /*
                  * Write ready, since we've made it here, so the connection
                  * has been made ... or has failed.
                  */
 
                 /*
                  * Now check (using getsockopt) that there is not an error
                  * state waiting for us on the socket.
                  */
 
                 if (getsockopt(conn->sock, SOL_SOCKET, SO_ERROR,
                                (char *) &optval, &optlen) == -1)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not get socket error status: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
                 else if (optval != 0)
                 {
                     /*
                      * When using a nonblocking connect, we will typically see
                      * connect failures at this point, so provide a friendly
                      * error message.
                      */
                     connectFailureMessage(conn, optval);
                     pqDropConnection(conn, true);
 
                     /*
                      * If more addresses remain, keep trying, just as in the
                      * case where connect() returned failure immediately.
                      */
                     if (conn->addr_cur->ai_next != NULL ||
                         conn->whichhost + 1 < conn->nconnhost)
                     {
                         conn->addr_cur = conn->addr_cur->ai_next;
                         conn->status = CONNECTION_NEEDED;
                         goto keep_going;
                     }
                     goto error_return;
                 }
 
                 /* Fill in the client address */
                 conn->laddr.salen = sizeof(conn->laddr.addr);
                 if (getsockname(conn->sock,
                                 (struct sockaddr *) &conn->laddr.addr,
                                 &conn->laddr.salen) < 0)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not get client address from socket: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     goto error_return;
                 }
 
                 /*
                  * Make sure we can write before advancing to next step.
                  */
                 conn->status = CONNECTION_MADE;
                 return PGRES_POLLING_WRITING;
             }
 
         case CONNECTION_MADE:
             {
                 char       *startpacket;
                 int         packetlen;
 
 #ifdef HAVE_UNIX_SOCKETS
 
                 /*
                  * Implement requirepeer check, if requested and it's a
                  * Unix-domain socket.
                  */
                 if (conn->requirepeer && conn->requirepeer[0] &&
                     IS_AF_UNIX(conn->raddr.addr.ss_family))
                 {
                     char        pwdbuf[BUFSIZ];
                     struct passwd pass_buf;
                     struct passwd *pass;
                     int         passerr;
                     uid_t       uid;
                     gid_t       gid;
 
                     errno = 0;
                     if (getpeereid(conn->sock, &uid, &gid) != 0)
                     {
                         /*
                          * Provide special error message if getpeereid is a
                          * stub
                          */
                         if (errno == ENOSYS)
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("requirepeer parameter is not supported on this platform\n"));
                         else
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("could not get peer credentials: %s\n"),
                                               pqStrerror(errno, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
 
                     passerr = pqGetpwuid(uid, &pass_buf, pwdbuf, sizeof(pwdbuf), &pass);
                     if (pass == NULL)
                     {
                         if (passerr != 0)
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("could not look up local user ID %d: %s\n"),
                                               (int) uid,
                                               pqStrerror(passerr, sebuf, sizeof(sebuf)));
                         else
                             appendPQExpBuffer(&conn->errorMessage,
                                               libpq_gettext("local user with ID %d does not exist\n"),
                                               (int) uid);
                         goto error_return;
                     }
 
                     if (strcmp(pass->pw_name, conn->requirepeer) != 0)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("requirepeer specifies \"%s\", but actual peer user name is \"%s\"\n"),
                                           conn->requirepeer, pass->pw_name);
                         goto error_return;
                     }
                 }
 #endif                          /* HAVE_UNIX_SOCKETS */
 
 #ifdef USE_SSL
 
                 /*
                  * If SSL is enabled and we haven't already got it running,
                  * request it instead of sending the startup message.
                  */
                 if (IS_AF_UNIX(conn->raddr.addr.ss_family))
                 {
                     /* Don't bother requesting SSL over a Unix socket */
                     conn->allow_ssl_try = false;
                 }
                 if (conn->allow_ssl_try && !conn->wait_ssl_try &&
                     !conn->ssl_in_use)
                 {
                     ProtocolVersion pv;
 
                     /*
                      * Send the SSL request packet.
                      *
                      * Theoretically, this could block, but it really
                      * shouldn't since we only got here if the socket is
                      * write-ready.
                      */
                     pv = htonl(NEGOTIATE_SSL_CODE);
                     if (pqPacketSend(conn, 0, &pv, sizeof(pv)) != STATUS_OK)
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not send SSL negotiation packet: %s\n"),
                                           SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                         goto error_return;
                     }
                     /* Ok, wait for response */
                     conn->status = CONNECTION_SSL_STARTUP;
                     return PGRES_POLLING_READING;
                 }
 #endif                          /* USE_SSL */
 
                 /*
                  * Build the startup packet.
                  */
                 if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                     startpacket = pqBuildStartupPacket3(conn, &packetlen,
                                                         EnvironmentOptions);
                 else
                     startpacket = pqBuildStartupPacket2(conn, &packetlen,
                                                         EnvironmentOptions);
                 if (!startpacket)
                 {
                     /*
                      * will not appendbuffer here, since it's likely to also
                      * run out of memory
                      */
                     printfPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("out of memory\n"));
                     goto error_return;
                 }
 
                 /*
                  * Send the startup packet.
                  *
                  * Theoretically, this could block, but it really shouldn't
                  * since we only got here if the socket is write-ready.
                  */
                 if (pqPacketSend(conn, 0, startpacket, packetlen) != STATUS_OK)
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext("could not send startup packet: %s\n"),
                                       SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
                     free(startpacket);
                     goto error_return;
                 }
 
                 free(startpacket);
 
                 conn->status = CONNECTION_AWAITING_RESPONSE;
                 return PGRES_POLLING_READING;
             }
 
             /*
              * Handle SSL negotiation: wait for postmaster messages and
              * respond as necessary.
              */
         case CONNECTION_SSL_STARTUP:
             {
 #ifdef USE_SSL
                 PostgresPollingStatusType pollres;
 
                 /*
                  * On first time through, get the postmaster's response to our
                  * SSL negotiation packet.
                  */
                 if (!conn->ssl_in_use)
                 {
                     /*
                      * We use pqReadData here since it has the logic to
                      * distinguish no-data-yet from connection closure. Since
                      * conn->ssl isn't set, a plain recv() will occur.
                      */
                     char        SSLok;
                     int         rdresult;
 
                     rdresult = pqReadData(conn);
                     if (rdresult < 0)
                     {
                         /* errorMessage is already filled in */
                         goto error_return;
                     }
                     if (rdresult == 0)
                     {
                         /* caller failed to wait for data */
                         return PGRES_POLLING_READING;
                     }
                     if (pqGetc(&SSLok, conn) < 0)
                     {
                         /* should not happen really */
                         return PGRES_POLLING_READING;
                     }
                     if (SSLok == 'S')
                     {
                         /* mark byte consumed */
                         conn->inStart = conn->inCursor;
                         /* Set up global SSL state if required */
                         if (pqsecure_initialize(conn) != 0)
                             goto error_return;
                     }
                     else if (SSLok == 'N')
                     {
                         /* mark byte consumed */
                         conn->inStart = conn->inCursor;
                         /* OK to do without SSL? */
                         if (conn->sslmode[0] == 'r' ||  /* "require" */
                             conn->sslmode[0] == 'v')    /* "verify-ca" or
                                                          * "verify-full" */
                         {
                             /* Require SSL, but server does not want it */
                             appendPQExpBufferStr(&conn->errorMessage,
                                                  libpq_gettext("server does not support SSL, but SSL was required\n"));
                             goto error_return;
                         }
                         /* Otherwise, proceed with normal startup */
                         conn->allow_ssl_try = false;
                         conn->status = CONNECTION_MADE;
                         return PGRES_POLLING_WRITING;
                     }
                     else if (SSLok == 'E')
                     {
                         /*
                          * Server failure of some sort, such as failure to
                          * fork a backend process.  We need to process and
                          * report the error message, which might be formatted
                          * according to either protocol 2 or protocol 3.
                          * Rather than duplicate the code for that, we flip
                          * into AWAITING_RESPONSE state and let the code there
                          * deal with it.  Note we have *not* consumed the "E"
                          * byte here.
                          */
                         conn->status = CONNECTION_AWAITING_RESPONSE;
                         goto keep_going;
                     }
                     else
                     {
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("received invalid response to SSL negotiation: %c\n"),
                                           SSLok);
                         goto error_return;
                     }
                 }
 
                 /*
                  * Begin or continue the SSL negotiation process.
                  */
                 pollres = pqsecure_open_client(conn);
                 if (pollres == PGRES_POLLING_OK)
                 {
                     /* SSL handshake done, ready to send startup packet */
                     conn->status = CONNECTION_MADE;
                     return PGRES_POLLING_WRITING;
                 }
                 if (pollres == PGRES_POLLING_FAILED)
                 {
                     /*
                      * Failed ... if sslmode is "prefer" then do a non-SSL
                      * retry
                      */
                     if (conn->sslmode[0] == 'p' /* "prefer" */
                         && conn->allow_ssl_try  /* redundant? */
                         && !conn->wait_ssl_try) /* redundant? */
                     {
                         /* only retry once */
                         conn->allow_ssl_try = false;
                         /* Must drop the old connection */
                         pqDropConnection(conn, true);
                         conn->status = CONNECTION_NEEDED;
                         goto keep_going;
                     }
                 }
                 return pollres;
 #else                           /* !USE_SSL */
                 /* can't get here */
                 goto error_return;
 #endif                          /* USE_SSL */
             }
 
             /*
              * Handle authentication exchange: wait for postmaster messages
              * and respond as necessary.
              */
         case CONNECTION_AWAITING_RESPONSE:
             {
                 char        beresp;
                 int         msgLength;
                 int         avail;
                 AuthRequest areq;
                 int         res;
 
                 /*
                  * Scan the message from current point (note that if we find
                  * the message is incomplete, we will return without advancing
                  * inStart, and resume here next time).
                  */
                 conn->inCursor = conn->inStart;
 
                 /* Read type byte */
                 if (pqGetc(&beresp, conn))
                 {
                     /* We'll come back when there is more data */
                     return PGRES_POLLING_READING;
                 }
 
                 /*
                  * Validate message type: we expect only an authentication
                  * request or an error here.  Anything else probably means
                  * it's not Postgres on the other end at all.
                  */
                 if (!(beresp == 'R' || beresp == 'E'))
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext(
                                                     "expected authentication request from "
                                                     "server, but received %c\n"),
                                       beresp);
                     goto error_return;
                 }
 
                 if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                 {
                     /* Read message length word */
                     if (pqGetInt(&msgLength, 4, conn))
                     {
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                 }
                 else
                 {
                     /* Set phony message length to disable checks below */
                     msgLength = 8;
                 }
 
                 /*
                  * Try to validate message length before using it.
                  * Authentication requests can't be very large, although GSS
                  * auth requests may not be that small.  Errors can be a
                  * little larger, but not huge.  If we see a large apparent
                  * length in an error, it means we're really talking to a
                  * pre-3.0-protocol server; cope.
                  */
                 if (beresp == 'R' && (msgLength < 8 || msgLength > 2000))
                 {
                     appendPQExpBuffer(&conn->errorMessage,
                                       libpq_gettext(
                                                     "expected authentication request from "
                                                     "server, but received %c\n"),
                                       beresp);
                     goto error_return;
                 }
 
                 if (beresp == 'E' && (msgLength < 8 || msgLength > 30000))
                 {
                     /* Handle error from a pre-3.0 server */
                     conn->inCursor = conn->inStart + 1; /* reread data */
                     if (pqGets_append(&conn->errorMessage, conn))
                     {
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                     /* OK, we read the message; mark data consumed */
                     conn->inStart = conn->inCursor;
 
                     /*
                      * The postmaster typically won't end its message with a
                      * newline, so add one to conform to libpq conventions.
                      */
                     appendPQExpBufferChar(&conn->errorMessage, '\n');
 
                     /*
                      * If we tried to open the connection in 3.0 protocol,
                      * fall back to 2.0 protocol.
                      */
                     if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                     {
                         conn->pversion = PG_PROTOCOL(2, 0);
                         /* Must drop the old connection */
                         pqDropConnection(conn, true);
                         conn->status = CONNECTION_NEEDED;
                         goto keep_going;
                     }
 
                     goto error_return;
                 }
 
                 /*
                  * Can't process if message body isn't all here yet.
                  *
                  * (In protocol 2.0 case, we are assuming messages carry at
                  * least 4 bytes of data.)
                  */
                 msgLength -= 4;
                 avail = conn->inEnd - conn->inCursor;
                 if (avail < msgLength)
                 {
                     /*
                      * Before returning, try to enlarge the input buffer if
                      * needed to hold the whole message; see notes in
                      * pqParseInput3.
                      */
                     if (pqCheckInBufferSpace(conn->inCursor + (size_t) msgLength,
                                              conn))
                         goto error_return;
                     /* We'll come back when there is more data */
                     return PGRES_POLLING_READING;
                 }
 
                 /* Handle errors. */
                 if (beresp == 'E')
                 {
                     if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
                     {
                         if (pqGetErrorNotice3(conn, true))
                         {
                             /* We'll come back when there is more data */
                             return PGRES_POLLING_READING;
                         }
                     }
                     else
                     {
                         if (pqGets_append(&conn->errorMessage, conn))
                         {
                             /* We'll come back when there is more data */
                             return PGRES_POLLING_READING;
                         }
                     }
                     /* OK, we read the message; mark data consumed */
                     conn->inStart = conn->inCursor;
 
 #ifdef USE_SSL
 
                     /*
                      * if sslmode is "allow" and we haven't tried an SSL
                      * connection already, then retry with an SSL connection
                      */
                     if (conn->sslmode[0] == 'a' /* "allow" */
                         && !conn->ssl_in_use
                         && conn->allow_ssl_try
                         && conn->wait_ssl_try)
                     {
                         /* only retry once */
                         conn->wait_ssl_try = false;
                         /* Must drop the old connection */
                         pqDropConnection(conn, true);
                         conn->status = CONNECTION_NEEDED;
                         goto keep_going;
                     }
 
                     /*
                      * if sslmode is "prefer" and we're in an SSL connection,
                      * then do a non-SSL retry
                      */
                     if (conn->sslmode[0] == 'p' /* "prefer" */
                         && conn->allow_ssl_try
                         && !conn->wait_ssl_try) /* redundant? */
                     {
                         /* only retry once */
                         conn->allow_ssl_try = false;
                         /* Must drop the old connection */
                         pqDropConnection(conn, true);
                         conn->status = CONNECTION_NEEDED;
                         goto keep_going;
                     }
 #endif
 
                     goto error_return;
                 }
 
                 /* It is an authentication request. */
                 conn->auth_req_received = true;
 
                 /* Get the type of request. */
                 if (pqGetInt((int *) &areq, 4, conn))
                 {
                     /* We'll come back when there are more data */
                     return PGRES_POLLING_READING;
                 }
                 msgLength -= 4;
 
                 /*
                  * Ensure the password salt is in the input buffer, if it's an
                  * MD5 request.  All the other authentication methods that
                  * contain extra data in the authentication request are only
                  * supported in protocol version 3, in which case we already
                  * read the whole message above.
                  */
                 if (areq == AUTH_REQ_MD5 && PG_PROTOCOL_MAJOR(conn->pversion) < 3)
                 {
                     msgLength += 4;
 
                     avail = conn->inEnd - conn->inCursor;
                     if (avail < 4)
                     {
                         /*
                          * Before returning, try to enlarge the input buffer
                          * if needed to hold the whole message; see notes in
                          * pqParseInput3.
                          */
                         if (pqCheckInBufferSpace(conn->inCursor + (size_t) 4,
                                                  conn))
                             goto error_return;
                         /* We'll come back when there is more data */
                         return PGRES_POLLING_READING;
                     }
                 }
 
                 /*
                  * Process the rest of the authentication request message, and
                  * respond to it if necessary.
                  *
                  * Note that conn->pghost must be non-NULL if we are going to
                  * avoid the Kerberos code doing a hostname look-up.
                  */
                 res = pg_fe_sendauth(areq, msgLength, conn);
                 conn->errorMessage.len = strlen(conn->errorMessage.data);
 
                 /* OK, we have processed the message; mark data consumed */
                 conn->inStart = conn->inCursor;
 
                 if (res != STATUS_OK)
                     goto error_return;
 
                 /*
                  * Just make sure that any data sent by pg_fe_sendauth is
                  * flushed out.  Although this theoretically could block, it
                  * really shouldn't since we don't send large auth responses.
                  */
                 if (pqFlush(conn))
                     goto error_return;
 
                 if (areq == AUTH_REQ_OK)
                 {
                     /* We are done with authentication exchange */
                     conn->status = CONNECTION_AUTH_OK;
 
                     /*
                      * Set asyncStatus so that PQgetResult will think that
                      * what comes back next is the result of a query.  See
                      * below.
                      */
                     conn->asyncStatus = PGASYNC_BUSY;
                 }
 
                 /* Look to see if we have more data yet. */
                 goto keep_going;
             }
 
         case CONNECTION_AUTH_OK:
             {
                 /*
                  * Now we expect to hear from the backend. A ReadyForQuery
                  * message indicates that startup is successful, but we might
                  * also get an Error message indicating failure. (Notice
                  * messages indicating nonfatal warnings are also allowed by
                  * the protocol, as are ParameterStatus and BackendKeyData
                  * messages.) Easiest way to handle this is to let
                  * PQgetResult() read the messages. We just have to fake it
                  * out about the state of the connection, by setting
                  * asyncStatus = PGASYNC_BUSY (done above).
                  */
 
                 if (PQisBusy(conn))
                     return PGRES_POLLING_READING;
 
                 res = PQgetResult(conn);
 
                 /*
                  * NULL return indicating we have gone to IDLE state is
                  * expected
                  */
                 if (res)
                 {
                     if (res->resultStatus != PGRES_FATAL_ERROR)
                         appendPQExpBufferStr(&conn->errorMessage,
                                              libpq_gettext("unexpected message from server during startup\n"));
                     else if (conn->send_appname &&
                              (conn->appname || conn->fbappname))
                     {
                         /*
                          * If we tried to send application_name, check to see
                          * if the error is about that --- pre-9.0 servers will
                          * reject it at this stage of the process.  If so,
                          * close the connection and retry without sending
                          * application_name.  We could possibly get a false
                          * SQLSTATE match here and retry uselessly, but there
                          * seems no great harm in that; we'll just get the
                          * same error again if it's unrelated.
                          */
                         const char *sqlstate;
 
                         sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
                         if (sqlstate &&
                             strcmp(sqlstate, ERRCODE_APPNAME_UNKNOWN) == 0)
                         {
                             PQclear(res);
                             conn->send_appname = false;
                             /* Must drop the old connection */
                             pqDropConnection(conn, true);
                             conn->status = CONNECTION_NEEDED;
                             goto keep_going;
                         }
                     }
 
                     /*
                      * if the resultStatus is FATAL, then conn->errorMessage
                      * already has a copy of the error; needn't copy it back.
                      * But add a newline if it's not there already, since
                      * postmaster error messages may not have one.
                      */
                     if (conn->errorMessage.len <= 0 ||
                         conn->errorMessage.data[conn->errorMessage.len - 1] != '\n')
                         appendPQExpBufferChar(&conn->errorMessage, '\n');
                     PQclear(res);
                     goto error_return;
                 }
 
                 /* Fire up post-connection housekeeping if needed */
                 if (PG_PROTOCOL_MAJOR(conn->pversion) < 3)
                 {
                     conn->status = CONNECTION_SETENV;
                     conn->setenv_state = SETENV_STATE_CLIENT_ENCODING_SEND;
                     conn->next_eo = EnvironmentOptions;
                     return PGRES_POLLING_WRITING;
                 }
 
                 /*
                  * If a read-write connection is required, see if we have one.
                  */
                 if (conn->target_session_attrs != NULL &&
                     strcmp(conn->target_session_attrs, "read-write") == 0)
                 {
                     /*
                      * We are yet to make a connection. Save all existing
                      * error messages until we make a successful connection
                      * state. This is important because PQsendQuery is going
                      * to reset conn->errorMessage and we will lose error
                      * messages related to previous hosts we have tried to
                      * connect and failed.
                      */
                     if (!saveErrorMessage(conn, &savedMessage))
                         goto error_return;
 
                     conn->status = CONNECTION_OK;
                     if (!PQsendQuery(conn,
                                      "SHOW transaction_read_only"))
                     {
                         restoreErrorMessage(conn, &savedMessage);
                         goto error_return;
                     }
                     conn->status = CONNECTION_CHECK_WRITABLE;
                     restoreErrorMessage(conn, &savedMessage);
                     return PGRES_POLLING_READING;
                 }
 
                 /* We can release the address lists now. */
                 release_all_addrinfo(conn);
 
                 /* We are open for business! */
                 conn->status = CONNECTION_OK;
                 return PGRES_POLLING_OK;
             }
 
         case CONNECTION_SETENV:
 
             /*
              * Do post-connection housekeeping (only needed in protocol 2.0).
              *
              * We pretend that the connection is OK for the duration of these
              * queries.
              */
             conn->status = CONNECTION_OK;
 
             switch (pqSetenvPoll(conn))
             {
                 case PGRES_POLLING_OK:  /* Success */
                     break;
 
                 case PGRES_POLLING_READING: /* Still going */
                     conn->status = CONNECTION_SETENV;
                     return PGRES_POLLING_READING;
 
                 case PGRES_POLLING_WRITING: /* Still going */
                     conn->status = CONNECTION_SETENV;
                     return PGRES_POLLING_WRITING;
 
                 default:
                     goto error_return;
             }
 
             /*
              * If a read-write connection is requested check for same.
              */
             if (conn->target_session_attrs != NULL &&
                 strcmp(conn->target_session_attrs, "read-write") == 0)
             {
                 if (!saveErrorMessage(conn, &savedMessage))
                     goto error_return;
 
                 conn->status = CONNECTION_OK;
                 if (!PQsendQuery(conn,
                                  "SHOW transaction_read_only"))
                 {
                     restoreErrorMessage(conn, &savedMessage);
                     goto error_return;
                 }
                 conn->status = CONNECTION_CHECK_WRITABLE;
                 restoreErrorMessage(conn, &savedMessage);
                 return PGRES_POLLING_READING;
             }
 
             /* We can release the address lists now. */
             release_all_addrinfo(conn);
 
             /* We are open for business! */
             conn->status = CONNECTION_OK;
             return PGRES_POLLING_OK;
 
         case CONNECTION_CONSUME:
             {
                 conn->status = CONNECTION_OK;
                 if (!PQconsumeInput(conn))
                     goto error_return;
 
                 if (PQisBusy(conn))
                 {
                     conn->status = CONNECTION_CONSUME;
                     restoreErrorMessage(conn, &savedMessage);
                     return PGRES_POLLING_READING;
                 }
 
                 /*
                  * Call PQgetResult() again to consume NULL result.
                  */
                 res = PQgetResult(conn);
                 if (res != NULL)
                 {
                     PQclear(res);
                     conn->status = CONNECTION_CONSUME;
                     goto keep_going;
                 }
 
                 /* We are open for business! */
                 conn->status = CONNECTION_OK;
                 return PGRES_POLLING_OK;
             }
         case CONNECTION_CHECK_WRITABLE:
             {
                 const char *displayed_host;
                 const char *displayed_port;
 
                 if (!saveErrorMessage(conn, &savedMessage))
                     goto error_return;
 
                 conn->status = CONNECTION_OK;
                 if (!PQconsumeInput(conn))
                 {
                     restoreErrorMessage(conn, &savedMessage);
                     goto error_return;
                 }
 
                 if (PQisBusy(conn))
                 {
                     conn->status = CONNECTION_CHECK_WRITABLE;
                     restoreErrorMessage(conn, &savedMessage);
                     return PGRES_POLLING_READING;
                 }
 
                 res = PQgetResult(conn);
                 if (res && (PQresultStatus(res) == PGRES_TUPLES_OK) &&
                     PQntuples(res) == 1)
                 {
                     char       *val;
 
                     val = PQgetvalue(res, 0, 0);
                     if (strncmp(val, "on", 2) == 0)
                     {
                         const char *displayed_host;
                         const char *displayed_port;
 
                         if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS)
                             displayed_host = conn->connhost[conn->whichhost].hostaddr;
                         else
                             displayed_host = conn->connhost[conn->whichhost].host;
                         displayed_port = conn->connhost[conn->whichhost].port;
                         if (displayed_port == NULL || displayed_port[0] == '\0')
                             displayed_port = DEF_PGPORT_STR;
 
                         PQclear(res);
                         restoreErrorMessage(conn, &savedMessage);
 
                         /* Not writable; close connection. */
                         appendPQExpBuffer(&conn->errorMessage,
                                           libpq_gettext("could not make a writable "
                                                         "connection to server "
                                                         "\"%s:%s\"\n"),
                                           displayed_host, displayed_port);
                         conn->status = CONNECTION_OK;
                         sendTerminateConn(conn);
                         pqDropConnection(conn, true);
 
                         /* Skip any remaining addresses for this host. */
                         conn->addr_cur = NULL;
                         if (conn->whichhost + 1 < conn->nconnhost)
                         {
                             conn->status = CONNECTION_NEEDED;
                             goto keep_going;
                         }
 
                         /* No more addresses to try. So we fail. */
                         goto error_return;
                     }
                     PQclear(res);
                     termPQExpBuffer(&savedMessage);
 
                     /* We can release the address lists now. */
                     release_all_addrinfo(conn);
 
                     /*
                      * Finish reading any remaining messages before being
                      * considered as ready.
                      */
                     conn->status = CONNECTION_CONSUME;
                     goto keep_going;
                 }
 
                 /*
                  * Something went wrong with "SHOW transaction_read_only". We
                  * should try next addresses.
                  */
                 if (res)
                     PQclear(res);
                 restoreErrorMessage(conn, &savedMessage);
 
                 if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS)
                     displayed_host = conn->connhost[conn->whichhost].hostaddr;
                 else
                     displayed_host = conn->connhost[conn->whichhost].host;
                 displayed_port = conn->connhost[conn->whichhost].port;
                 if (displayed_port == NULL || displayed_port[0] == '\0')
                     displayed_port = DEF_PGPORT_STR;
                 appendPQExpBuffer(&conn->errorMessage,
                                   libpq_gettext("test \"SHOW transaction_read_only\" failed "
                                                 "on server \"%s:%s\"\n"),
                                   displayed_host, displayed_port);
                 conn->status = CONNECTION_OK;
                 sendTerminateConn(conn);
                 pqDropConnection(conn, true);
 
                 if (conn->addr_cur->ai_next != NULL ||
                     conn->whichhost + 1 < conn->nconnhost)
                 {
                     conn->addr_cur = conn->addr_cur->ai_next;
                     conn->status = CONNECTION_NEEDED;
                     goto keep_going;
                 }
 
                 /* No more addresses to try. So we fail. */
                 goto error_return;
             }
 
         default:
             appendPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("invalid connection state %d, "
                                             "probably indicative of memory corruption\n"),
                               conn->status);
             goto error_return;
     }
 
     /* Unreachable */
 
 error_return:
 
     pgpassfileWarning(conn);
 
     /*
      * We used to close the socket at this point, but that makes it awkward
      * for those above us if they wish to remove this socket from their own
      * records (an fd_set for example).  We'll just have this socket closed
      * when PQfinish is called (which is compulsory even after an error, since
      * the connection structure must be freed).
      */
     conn->status = CONNECTION_BAD;
     return PGRES_POLLING_FAILED;
 }

PGconn* PQconnectStart ( const char * conninfo )

Definition at line 711 of file fe-connect.c.

References conn, connectDBStart(), CONNECTION_BAD, connectOptions1(), connectOptions2(), makeEmptyPGconn(), NULL, and pg_conn::status.

Referenced by PQconnectdb(), and PQping().

 {
     PGconn     *conn;
 
     /*
      * Allocate memory for the conn structure
      */
     conn = makeEmptyPGconn();
     if (conn == NULL)
         return NULL;
 
     /*
      * Parse the conninfo string
      */
     if (!connectOptions1(conn, conninfo))
         return conn;
 
     /*
      * Compute derived options
      */
     if (!connectOptions2(conn))
         return conn;
 
     /*
      * Connect to the database
      */
     if (!connectDBStart(conn))
     {
         /* Just in case we failed to set it in connectDBStart */
         conn->status = CONNECTION_BAD;
     }
 
     return conn;
 }

PGconn* PQconnectStartParams	(	const char const	keywords,
		const char const	values,
		int	expand_dbname
	)

Definition at line 632 of file fe-connect.c.

References conn, connectDBStart(), CONNECTION_BAD, connectOptions2(), conninfo_array_parse(), pg_conn::errorMessage, fillPGconn(), makeEmptyPGconn(), NULL, PQconninfoFree(), and pg_conn::status.

Referenced by libpqrcv_connect(), PQconnectdbParams(), and PQpingParams().

 {
     PGconn     *conn;
     PQconninfoOption *connOptions;
 
     /*
      * Allocate memory for the conn structure
      */
     conn = makeEmptyPGconn();
     if (conn == NULL)
         return NULL;
 
     /*
      * Parse the conninfo arrays
      */
     connOptions = conninfo_array_parse(keywords, values,
                                        &conn->errorMessage,
                                        true, expand_dbname);
     if (connOptions == NULL)
     {
         conn->status = CONNECTION_BAD;
         /* errorMessage is already set */
         return conn;
     }
 
     /*
      * Move option values into conn structure
      */
     if (!fillPGconn(conn, connOptions))
     {
         PQconninfoFree(connOptions);
         return conn;
     }
 
     /*
      * Free the option info - all is in conn now
      */
     PQconninfoFree(connOptions);
 
     /*
      * Compute derived options
      */
     if (!connectOptions2(conn))
         return conn;
 
     /*
      * Connect to the database
      */
     if (!connectDBStart(conn))
     {
         /* Just in case we failed to set it in connectDBStart */
         conn->status = CONNECTION_BAD;
     }
 
     return conn;
 }

PQconninfoOption* PQconninfo ( PGconn * conn )

Definition at line 5906 of file fe-connect.c.

References conninfo_init(), conninfo_storeval(), _internalPQconninfoOption::connofs, initPQExpBuffer(), _internalPQconninfoOption::keyword, NULL, PQExpBufferDataBroken, and termPQExpBuffer().

Referenced by exec_command_conninfo(), GenerateRecoveryConf(), and libpqrcv_get_conninfo().

 {
     PQExpBufferData errorBuf;
     PQconninfoOption *connOptions;
 
     if (conn == NULL)
         return NULL;
 
     /* We don't actually report any errors here, but callees want a buffer */
     initPQExpBuffer(&errorBuf);
     if (PQExpBufferDataBroken(errorBuf))
         return NULL;            /* out of memory already :-( */
 
     connOptions = conninfo_init(&errorBuf);
 
     if (connOptions != NULL)
     {
         const internalPQconninfoOption *option;
 
         for (option = PQconninfoOptions; option->keyword; option++)
         {
             char      **connmember;
 
             if (option->connofs < 0)
                 continue;
 
             connmember = (char **) ((char *) conn + option->connofs);
 
             if (*connmember)
                 conninfo_storeval(connOptions, option->keyword, *connmember,
                                   &errorBuf, true, false);
         }
     }
 
     termPQExpBuffer(&errorBuf);
 
     return connOptions;
 }

void PQconninfoFree ( PQconninfoOption * connOptions )

Definition at line 5947 of file fe-connect.c.

References free, _PQconninfoOption::keyword, NULL, and _PQconninfoOption::val.

Referenced by check_pghost_envvar(), connectDatabase(), connectOptions1(), conninfo_array_parse(), conninfo_parse(), conninfo_uri_parse(), dblink_connstr_check(), exec_command_conninfo(), GenerateRecoveryConf(), GetConnection(), libpqrcv_check_conninfo(), libpqrcv_get_conninfo(), PQconndefaults(), and PQconnectStartParams().

 {
     PQconninfoOption *option;
 
     if (connOptions == NULL)
         return;
 
     for (option = connOptions; option->keyword != NULL; option++)
     {
         if (option->val != NULL)
             free(option->val);
     }
     free(connOptions);
 }

PQconninfoOption* PQconninfoParse	(	const char *	conninfo,
		char **	errmsg
	)

Definition at line 4717 of file fe-connect.c.

References PQExpBufferData::data, initPQExpBuffer(), NULL, parse_connection_string(), PQExpBufferDataBroken, and termPQExpBuffer().

Referenced by connectDatabase(), dblink_connstr_check(), GetConnection(), libpqrcv_check_conninfo(), and main().

 {
     PQExpBufferData errorBuf;
     PQconninfoOption *connOptions;
 
     if (errmsg)
         *errmsg = NULL;         /* default */
     initPQExpBuffer(&errorBuf);
     if (PQExpBufferDataBroken(errorBuf))
         return NULL;            /* out of memory already :-( */
     connOptions = parse_connection_string(conninfo, &errorBuf, false);
     if (connOptions == NULL && errmsg)
         *errmsg = errorBuf.data;
     else
         termPQExpBuffer(&errorBuf);
     return connOptions;
 }

int PQconsumeInput ( PGconn * conn )

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

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

Referenced by CopyStreamReceive(), dblink_get_notify(), dblink_is_busy(), doCustom(), GetIdleSlot(), libpqrcv_PQexec(), libpqrcv_receive(), main(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PQconnectPoll(), StreamLogicalLog(), and try_complete_step().

 {
     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;
 }

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

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

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

Referenced by pqRowProcessor().

 {
     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);
         if (!dest->events)
         {
             PQclear(dest);
             return NULL;
         }
         dest->nEvents = src->nEvents;
     }
 
     /* Okay, trigger PGEVT_RESULTCOPY event */
     for (i = 0; i < dest->nEvents; i++)
     {
         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))
             {
                 PQclear(dest);
                 return NULL;
             }
             dest->events[i].resultInitialized = TRUE;
         }
     }
 
     return dest;
 }

char* PQdb ( const PGconn * conn )

Definition at line 5965 of file fe-connect.c.

References pg_conn::dbName, and NULL.

Referenced by _connectDB(), CloneArchive(), cluster_one_database(), ConnectDatabase(), do_connect(), dumpDatabase(), exec_command_conninfo(), get_prompt(), GetQueryResult(), main(), ReconnectToServer(), reindex_one_database(), reindex_system_catalogs(), run_vacuum_command(), slashUsage(), SyncVariables(), vacuum_one_database(), and WriteHead().

 {
     if (!conn)
         return NULL;
     return conn->dbName;
 }

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

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

References NULL, PQexecFinish(), PQexecStart(), and PQsendDescribe().

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

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

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

References NULL, PQexecFinish(), PQexecStart(), and PQsendDescribe().

Referenced by ECPGdescribe().

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

void PQdisplayTuples	(	const PGresult *	res,
		FILE *	fp,
		int	fillAlign,
		const char *	fieldSep,
		int	printHeader,
		int	quiet
	)

Definition at line 571 of file fe-print.c.

References DEFAULT_FIELD_SEP, fill(), free, i, libpq_gettext, malloc, NULL, PQfname(), PQgetlength(), PQgetvalue(), PQnfields(), and PQntuples().

 {
 #define DEFAULT_FIELD_SEP " "
 
     int         i,
                 j;
     int         nFields;
     int         nTuples;
     int        *fLength = NULL;
 
     if (fieldSep == NULL)
         fieldSep = DEFAULT_FIELD_SEP;
 
     /* Get some useful info about the results */
     nFields = PQnfields(res);
     nTuples = PQntuples(res);
 
     if (fp == NULL)
         fp = stdout;
 
     /* Figure the field lengths to align to */
     /* will be somewhat time consuming for very large results */
     if (fillAlign)
     {
         fLength = (int *) malloc(nFields * sizeof(int));
         if (!fLength)
         {
             fprintf(stderr, libpq_gettext("out of memory\n"));
             abort();
         }
 
         for (j = 0; j < nFields; j++)
         {
             fLength[j] = strlen(PQfname(res, j));
             for (i = 0; i < nTuples; i++)
             {
                 int         flen = PQgetlength(res, i, j);
 
                 if (flen > fLength[j])
                     fLength[j] = flen;
             }
         }
     }
 
     if (printHeader)
     {
         /* first, print out the attribute names */
         for (i = 0; i < nFields; i++)
         {
             fputs(PQfname(res, i), fp);
             if (fillAlign)
                 fill(strlen(PQfname(res, i)), fLength[i], ' ', fp);
             fputs(fieldSep, fp);
         }
         fprintf(fp, "\n");
 
         /* Underline the attribute names */
         for (i = 0; i < nFields; i++)
         {
             if (fillAlign)
                 fill(0, fLength[i], '-', fp);
             fputs(fieldSep, fp);
         }
         fprintf(fp, "\n");
     }
 
     /* next, print out the instances */
     for (i = 0; i < nTuples; i++)
     {
         for (j = 0; j < nFields; j++)
         {
             fprintf(fp, "%s", PQgetvalue(res, i, j));
             if (fillAlign)
                 fill(strlen(PQgetvalue(res, i, j)), fLength[j], ' ', fp);
             fputs(fieldSep, fp);
         }
         fprintf(fp, "\n");
     }
 
     if (!quiet)
         fprintf(fp, "\nQuery returned %d row%s.\n", PQntuples(res),
                 (PQntuples(res) == 1) ? "" : "s");
 
     fflush(fp);
 
     if (fLength)
         free(fLength);
 }

int PQdsplen	(	const char *	s,
		int	encoding
	)

Definition at line 1192 of file fe-misc.c.

References pg_encoding_dsplen().

Referenced by pg_wcsformat(), pg_wcssize(), pg_wcswidth(), and strlen_max_width().

 {
     return pg_encoding_dsplen(encoding, s);
 }

char* PQencryptPassword	(	const char *	passwd,
		const char *	user
	)

Definition at line 1098 of file fe-auth.c.

References free, malloc, MD5_PASSWD_LEN, NULL, and pg_md5_encrypt().

 {
     char       *crypt_pwd;
 
     crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
     if (!crypt_pwd)
         return NULL;
 
     if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd))
     {
         free(crypt_pwd);
         return NULL;
     }
 
     return crypt_pwd;
 }

char* PQencryptPasswordConn	(	PGconn *	conn,
		const char *	passwd,
		const char *	user,
		const char *	algorithm
	)

Definition at line 1140 of file fe-auth.c.

References pg_conn::errorMessage, free, libpq_gettext, malloc, MAX_ALGORITHM_NAME_LEN, MD5_PASSWD_LEN, NULL, pg_fe_scram_build_verifier(), pg_md5_encrypt(), PGRES_TUPLES_OK, PQclear(), PQexec(), PQgetvalue(), PQnfields(), PQntuples(), PQresultStatus(), printfPQExpBuffer(), and val.

Referenced by exec_command_password(), and main().

 {
 #define MAX_ALGORITHM_NAME_LEN 50
     char        algobuf[MAX_ALGORITHM_NAME_LEN + 1];
     char       *crypt_pwd = NULL;
 
     if (!conn)
         return NULL;
 
     /* If no algorithm was given, ask the server. */
     if (algorithm == NULL)
     {
         PGresult   *res;
         char       *val;
 
         res = PQexec(conn, "show password_encryption");
         if (res == NULL)
         {
             /* PQexec() should've set conn->errorMessage already */
             return NULL;
         }
         if (PQresultStatus(res) != PGRES_TUPLES_OK)
         {
             /* PQexec() should've set conn->errorMessage already */
             PQclear(res);
             return NULL;
         }
         if (PQntuples(res) != 1 || PQnfields(res) != 1)
         {
             PQclear(res);
             printfPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("unexpected shape of result set returned for SHOW\n"));
             return NULL;
         }
         val = PQgetvalue(res, 0, 0);
 
         if (strlen(val) > MAX_ALGORITHM_NAME_LEN)
         {
             PQclear(res);
             printfPQExpBuffer(&conn->errorMessage,
                               libpq_gettext("password_encryption value too long\n"));
             return NULL;
         }
         strcpy(algobuf, val);
         PQclear(res);
 
         algorithm = algobuf;
     }
 
     /*
      * Also accept "on" and "off" as aliases for "md5", because
      * password_encryption was a boolean before PostgreSQL 10.  We refuse to
      * send the password in plaintext even if it was "off".
      */
     if (strcmp(algorithm, "on") == 0 ||
         strcmp(algorithm, "off") == 0)
         algorithm = "md5";
 
     /*
      * Ok, now we know what algorithm to use
      */
     if (strcmp(algorithm, "scram-sha-256") == 0)
     {
         crypt_pwd = pg_fe_scram_build_verifier(passwd);
     }
     else if (strcmp(algorithm, "md5") == 0)
     {
         crypt_pwd = malloc(MD5_PASSWD_LEN + 1);
         if (crypt_pwd)
         {
             if (!pg_md5_encrypt(passwd, user, strlen(user), crypt_pwd))
             {
                 free(crypt_pwd);
                 crypt_pwd = NULL;
             }
         }
     }
     else
     {
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("unrecognized password encryption algorithm \"%s\"\n"),
                           algorithm);
         return NULL;
     }
 
     if (!crypt_pwd)
         printfPQExpBuffer(&conn->errorMessage,
                           libpq_gettext("out of memory\n"));
 
     return crypt_pwd;
 }

int PQendcopy ( PGconn * conn )

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

References PG_PROTOCOL_MAJOR, pqEndcopy2(), pqEndcopy3(), and pg_conn::pversion.

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

 {
     if (!conn)
         return 0;
 
     if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
         return pqEndcopy3(conn);
     else
         return pqEndcopy2(conn);
 }

int PQenv2encoding ( void )

Definition at line 1201 of file fe-misc.c.

References encoding, pg_char_to_encoding(), and PG_SQL_ASCII.

Referenced by main().

 {
     char       *str;
     int         encoding = PG_SQL_ASCII;
 
     str = getenv("PGCLIENTENCODING");
     if (str && *str != '\0')
     {
         encoding = pg_char_to_encoding(str);
         if (encoding < 0)
             encoding = PG_SQL_ASCII;
     }
     return encoding;
 }

char* PQerrorMessage ( const PGconn * conn )

Definition at line 6097 of file fe-connect.c.

References PQExpBufferData::data, pg_conn::errorMessage, and libpq_gettext.

Referenced by _connectDB(), _doSetSessionAuth(), _doSetWithOids(), _selectOutputSchema(), _selectTablespace(), AcceptResult(), BaseBackup(), check_conn(), check_loadable_libraries(), CheckCopyStreamStop(), cluster_one_database(), connect_pg_server(), connectDatabase(), ConnectDatabase(), connectToServer(), CopyStreamPoll(), CopyStreamReceive(), CreateReplicationSlot(), dblink_connect(), dblink_error_message(), dblink_get_conn(), dblink_res_error(), dblink_send_query(), die_on_query_failure(), do_connect(), do_lo_export(), do_lo_import(), do_lo_unlink(), doConnect(), doCustom(), DropReplicationSlot(), dumpBlobs(), dumpTableData_copy(), ecpg_check_PQresult(), ecpg_raise_backend(), ECPGconnect(), EndDBCopyMode(), exec_command_password(), executeCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlCommandBuf(), executeStatement(), fetch_file_range(), GetConnection(), GetQueryResult(), handleCopyIn(), handleCopyOut(), HandleEndOfCopyStream(), init(), init_slot(), libpq_executeFileMap(), libpqConnect(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_endstreaming(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_readtimelinehistoryfile(), libpqrcv_receive(), libpqrcv_send(), libpqrcv_startstreaming(), main(), my_truncate(), overwrite(), pg_attribute_noreturn(), pgfdw_report_error(), pickout(), ProcessXLogDataMsg(), psql_get_variable(), ReceiveAndUnpackTarFile(), receiveFileChunks(), ReceiveTarFile(), ReceiveXlogStream(), reindex_one_database(), reindex_system_catalogs(), run_permutation(), run_vacuum_command(), RunIdentifySystem(), sendCommand(), sendFeedback(), SendQuery(), sql_conn(), sql_exec(), start_postmaster(), StartRestoreBlob(), storeQueryResult(), StreamLogicalLog(), threadRun(), try_complete_step(), tryExecuteStatement(), and vacuumlo().

 {
     if (!conn)
         return libpq_gettext("connection pointer is NULL\n");
 
     return conn->errorMessage.data;
 }

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

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

References NULL, PQescapeByteaInternal(), and static_std_strings.

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

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

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

References NULL, PQescapeByteaInternal(), pg_conn::std_strings, and pg_conn::sversion.

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

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

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

References PQescapeInternal().

Referenced by init(), psql_get_variable(), stringlist_to_identifierstr(), and vacuumlo().

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

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

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

References PQescapeInternal().

Referenced by libpqrcv_startstreaming(), and psql_get_variable().

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

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

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

References NULL, PQescapeStringInternal(), static_client_encoding, and static_std_strings.

Referenced by get_comma_elts(), and quote_postgres().

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

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

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

References pg_conn::client_encoding, PQescapeStringInternal(), and pg_conn::std_strings.

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

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

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

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

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

Referenced by _doSetSessionAuth(), _doSetWithOids(), _selectOutputSchema(), _selectTablespace(), check_loadable_libraries(), CreateReplicationSlot(), dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), deallocate_one(), DropReplicationSlot(), ecpg_autostart_transaction(), ecpg_execute(), ecpg_is_type_an_array(), ECPGsetcommit(), ECPGtrans(), ExecQueryUsingCursor(), executeCommand(), executeMaintenanceCommand(), executeQuery(), executeQueryOrDie(), ExecuteSqlCommand(), ExecuteSqlQuery(), ExecuteSqlStatement(), executeStatement(), get_create_object_cmd(), init(), libpq_executeFileMap(), libpqConnect(), libpqProcessFileList(), lo_initialize(), lockTableForWorker(), lookup_object_oid(), main(), pgfdw_xact_callback(), PQencryptPasswordConn(), PQsetClientEncoding(), PSQLexec(), PSQLexecWatch(), ReceiveXlogStream(), run_permutation(), run_simple_query(), RunIdentifySystem(), SendQuery(), sql_exec(), StreamLogicalLog(), tryExecuteStatement(), and vacuumlo().

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

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

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

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

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

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

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

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

Referenced by ecpg_execute(), and try_complete_step().

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

int PQfformat	(	const PGresult *	res,
		int	field_num
	)

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

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

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

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

void PQfinish ( PGconn * conn )

Definition at line 3630 of file fe-connect.c.

References closePGconn(), and freePGconn().

Referenced by _connectDB(), BaseBackup(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_is_install_user(), check_loadable_libraries(), check_proper_datallowconn(), CheckConnection(), cluster_all_databases(), cluster_one_database(), connect_pg_server(), connectDatabase(), ConnectDatabase(), connectToServer(), createNewConnection(), dblink_connect(), dblink_disconnect(), dblink_exec(), dblink_get_conn(), dblink_record_internal(), dblink_security_check(), disconnect_all(), disconnect_and_exit(), disconnect_pg_server(), DisconnectDatabase(), do_connect(), doConnect(), doCustom(), dumpCreateDB(), dumpTablespaces(), ecpg_finish(), executeCommand(), executeQuery(), executeQueryOrDie(), exit_nicely(), get_db_infos(), get_loadable_libraries(), get_rel_infos(), get_tablespace_paths(), GetConnection(), init(), libpqrcv_disconnect(), LogStreamerMain(), main(), new_9_0_populate_pg_largeobject_metadata(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), PQping(), PQpingParams(), ReconnectToServer(), reindex_all_databases(), reindex_one_database(), reindex_system_catalogs(), run_vacuum_command(), set_frozenxids(), sql_conn(), sql_exec(), start_postmaster(), StreamLog(), StreamLogicalLog(), threadRun(), vacuum_all_databases(), and vacuumlo().

 {
     if (conn)
     {
         closePGconn(conn);
         freePGconn(conn);
     }
 }

int PQflush ( PGconn * conn )

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

References pqFlush().

Referenced by CheckCopyStreamStop(), HandleEndOfCopyStream(), libpqrcv_endstreaming(), libpqrcv_send(), prepareToTerminate(), ProcessXLogDataMsg(), and sendFeedback().

 {
     return pqFlush(conn);
 }

int PQfmod	(	const PGresult *	res,
		int	field_num
	)

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

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

Referenced by ECPGget_desc().

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

PGresult* PQfn	(	PGconn *	conn,
		int	fnid,
		int *	result_buf,
		int *	result_len,
		int

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation