39 "PGRES_NONFATAL_ERROR",
43 "PGRES_PIPELINE_SYNC",
44 "PGRES_PIPELINE_ABORTED"
51 .errMsg =
"out of memory\n",
64 const char **errmsgp);
71 const Oid *paramTypes,
72 const char *
const *paramValues,
73 const int *paramLengths,
74 const int *paramFormats,
81 const char *desc_target);
140 #define PGRESULT_DATA_BLOCKSIZE 2048
141 #define PGRESULT_ALIGN_BOUNDARY MAXIMUM_ALIGNOF
142 #define PGRESULT_BLOCK_OVERHEAD Max(sizeof(PGresult_data), PGRESULT_ALIGN_BOUNDARY)
143 #define PGRESULT_SEP_ALLOC_THRESHOLD (PGRESULT_DATA_BLOCKSIZE / 2)
259 if (numAttributes <= 0 || !attDescs)
347 for (tup = 0; tup < src->
ntups; tup++)
380 for (
i = 0;
i <
dest->nEvents;
i++)
390 dest->events[
i].passThrough))
391 dest->events[
i].resultInitialized =
true;
411 if (!events || count <= 0)
414 msize = count *
sizeof(
PGEvent);
419 for (
i = 0;
i < count;
i++)
423 newEvents[
i].
data = NULL;
426 if (!newEvents[
i].
name)
433 msize += strlen(events[
i].
name) + 1;
452 const char *
errmsg = NULL;
463 if (tup_num < 0 || tup_num >
res->
ntups)
466 "row number %d is out of range 0..%d",
496 attval = &
res->
tuples[tup_num][field_num];
946 msgBuf[
sizeof(msgBuf) - 1] =
'\0';
1016 *errmsgp =
libpq_gettext(
"PGresult cannot support more than INT_MAX tuples");
1025 #if INT_MAX >= (SIZE_MAX / 2)
1066 pfield->
code = code;
1086 prev = pstatus, pstatus = pstatus->
next)
1088 if (strcmp(pstatus->
name,
name) == 0)
1109 pstatus->
name = ptr;
1111 ptr += strlen(
name) + 1;
1112 pstatus->
value = ptr;
1125 if (strcmp(
name,
"client_encoding") == 0)
1133 else if (strcmp(
name,
"standard_conforming_strings") == 0)
1138 else if (strcmp(
name,
"server_version") == 0)
1146 cnt = sscanf(
value,
"%d.%d.%d", &vmaj, &vmin, &vrev);
1174 else if (strcmp(
name,
"default_transaction_read_only") == 0)
1179 else if (strcmp(
name,
"in_hot_standby") == 0)
1239 for (
i = 0;
i < nfields;
i++)
1241 int clen = columns[
i].
len;
1327 entry->
query = NULL;
1399 entry->
query = NULL;
1469 entry->
query = strdup(query);
1495 const char *command,
1497 const Oid *paramTypes,
1498 const char *
const *paramValues,
1499 const int *paramLengths,
1500 const int *paramFormats,
1539 const char *stmtName,
const char *query,
1540 int nParams,
const Oid *paramTypes)
1575 if (nParams > 0 && paramTypes)
1581 for (
i = 0;
i < nParams;
i++)
1608 entry->
query = strdup(query);
1636 const char *stmtName,
1638 const char *
const *paramValues,
1639 const int *paramLengths,
1640 const int *paramFormats,
1758 const char *command,
1759 const char *stmtName,
1761 const Oid *paramTypes,
1762 const char *
const *paramValues,
1763 const int *paramLengths,
1764 const int *paramFormats,
1787 if (nParams > 0 && paramTypes)
1791 for (
i = 0;
i < nParams;
i++)
1813 if (nParams > 0 && paramFormats)
1817 for (
i = 0;
i < nParams;
i++)
1833 for (
i = 0;
i < nParams;
i++)
1835 if (paramValues && paramValues[
i])
1839 if (paramFormats && paramFormats[
i] != 0)
1843 nbytes = paramLengths[
i];
1853 nbytes = strlen(paramValues[
i]);
1900 entry->
query = strdup(command);
2240 const char *command,
2242 const Oid *paramTypes,
2243 const char *
const *paramValues,
2244 const int *paramLengths,
2245 const int *paramFormats,
2251 nParams, paramTypes, paramValues, paramLengths,
2252 paramFormats, resultFormat))
2270 const char *stmtName,
const char *query,
2271 int nParams,
const Oid *paramTypes)
2287 const char *stmtName,
2289 const char *
const *paramValues,
2290 const int *paramLengths,
2291 const int *paramFormats,
2297 nParams, paramValues, paramLengths,
2298 paramFormats, resultFormat))
2393 lastResult = result;
2738 if (!buffer || length <= 0)
2897 result_buf, result_len,
3027 prevquery->
next = NULL;
3161 "internal error: cannot send pipeline while in COPY\n");
3177 entry->
query = NULL;
3278 return strdup(
libpq_gettext(
"PGresult is not an error result\n"));
3291 return workBuf.
data;
3303 if (pfield->
code == fieldcode)
3346 "column number %d is out of range 0..%d",
3355 int tup_num,
int field_num)
3359 if (tup_num < 0 || tup_num >=
res->
ntups)
3362 "row number %d is out of range 0..%d",
3369 "column number %d is out of range 0..%d",
3384 "parameter number %d is out of range 0..%d",
3422 bool all_lower =
true;
3434 if (field_name == NULL ||
3435 field_name[0] ==
'\0' ||
3443 for (iptr = field_name; *iptr; iptr++)
3466 field_case = strdup(field_name);
3467 if (field_case == NULL)
3472 for (iptr = field_case; *iptr; iptr++)
3600 static char buf[24];
3608 if (
len >
sizeof(
buf) - 1)
3624 char *endptr = NULL;
3625 unsigned long result;
3635 if (!endptr || (*endptr !=
' ' && *endptr !=
'\0'))
3638 return (
Oid) result;
3663 while (*p && *p !=
' ')
3666 goto interpret_error;
3683 for (
c = p; *
c;
c++)
3685 if (!isdigit((
unsigned char) *
c))
3686 goto interpret_error;
3689 goto interpret_error;
3695 "could not interpret result from server: %s",
3823 #ifdef ENABLE_THREAD_SAFETY
3905 char *to,
const char *from,
size_t length,
3909 const char *
source = from;
3939 for (
i = 0;
i <
len;
i++)
3961 for (;
i <
len;
i++)
3963 if (((
size_t) (target - to)) / 2 >= length)
3979 char *to,
const char *from,
size_t length,
4021 int num_backslashes = 0;
4024 char quote_char = as_ident ?
'"' :
'\'';
4034 for (s =
str; (s -
str) <
len && *s !=
'\0'; ++s)
4036 if (*s == quote_char)
4038 else if (*s ==
'\\')
4048 if ((s -
str) + charlen >
len || memchr(s, 0, charlen) != NULL)
4060 input_len = s -
str;
4061 result_size = input_len + num_quotes + 3;
4062 if (!as_ident && num_backslashes > 0)
4063 result_size += num_backslashes + 2;
4064 result = rp = (
char *)
malloc(result_size);
4078 if (!as_ident && num_backslashes > 0)
4098 if (num_quotes == 0 && (num_backslashes == 0 || as_ident))
4100 memcpy(rp,
str, input_len);
4105 for (s =
str; s -
str < input_len; ++s)
4107 if (*s == quote_char || (!as_ident && *s ==
'\\'))
4149 static const char hextbl[] =
"0123456789abcdef";
4152 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4153 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4154 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4155 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
4156 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4157 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4158 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4167 if (
c > 0 &&
c < 127)
4189 static unsigned char *
4191 const unsigned char *from,
size_t from_length,
4192 size_t *to_length,
bool std_strings,
bool use_hex)
4194 const unsigned char *vp;
4196 unsigned char *result;
4199 size_t bslash_len = (std_strings ? 1 : 2);
4208 len += bslash_len + 1 + 2 * from_length;
4213 for (
i = from_length;
i > 0;
i--, vp++)
4215 if (*vp < 0x20 || *vp > 0x7e)
4216 len += bslash_len + 3;
4217 else if (*vp ==
'\'')
4219 else if (*vp ==
'\\')
4220 len += bslash_len + bslash_len;
4227 rp = result = (
unsigned char *)
malloc(
len);
4244 for (
i = from_length;
i > 0;
i--, vp++)
4246 unsigned char c = *vp;
4250 *rp++ =
hextbl[(
c >> 4) & 0xF];
4258 *rp++ = (
c >> 6) +
'0';
4259 *rp++ = ((
c >> 3) & 07) +
'0';
4260 *rp++ = (
c & 07) +
'0';
4287 const unsigned char *from,
size_t from_length,
4310 #define ISFIRSTOCTDIGIT(CH) ((CH) >= '0' && (CH) <= '3')
4311 #define ISOCTDIGIT(CH) ((CH) >= '0' && (CH) <= '7')
4312 #define OCTVAL(CH) ((CH) - '0')
4331 unsigned char *buffer,
4336 if (strtext == NULL)
4339 strtextlen = strlen((
const char *) strtext);
4341 if (strtext[0] ==
'\\' && strtext[1] ==
'x')
4343 const unsigned char *s;
4346 buflen = (strtextlen - 2) / 2;
4348 buffer = (
unsigned char *)
malloc(buflen > 0 ? buflen : 1);
4364 if (!*s || v1 == (
char) -1)
4367 if (v2 != (
char) -1)
4368 *p++ = (v1 << 4) | v2;
4371 buflen = p - buffer;
4379 buffer = (
unsigned char *)
malloc(strtextlen + 1);
4383 for (
i =
j = 0;
i < strtextlen;)
4389 if (strtext[
i] ==
'\\')
4390 buffer[
j++] = strtext[
i++];
4400 byte = (
byte << 3) +
OCTVAL(strtext[
i++]);
4401 byte = (
byte << 3) +
OCTVAL(strtext[
i++]);
4416 buffer[
j++] = strtext[
i++];
4434 *retbuflen = buflen;
#define unconstify(underlying_type, expr)
#define IS_HIGHBIT_SET(ch)
#define SQL_STR_DOUBLE(ch, escape_backslash)
static void PGresult * res
int errmsg(const char *fmt,...)
int pg_char_to_encoding(const char *name)
static char * PQescapeInternal(PGconn *conn, const char *str, size_t len, bool as_ident)
static int PQsendQueryInternal(PGconn *conn, const char *query, bool newQuery)
unsigned char * PQescapeBytea(const unsigned char *from, size_t from_length, size_t *to_length)
PGresult * PQfn(PGconn *conn, int fnid, int *result_buf, int *result_len, int result_is_int, const PQArgBlock *args, int nargs)
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 PQsendQueryContinue(PGconn *conn, const char *query)
int PQgetlength(const PGresult *res, int tup_num, int field_num)
int PQsetSingleRowMode(PGconn *conn)
static char get_hex(char c)
int PQbinaryTuples(const PGresult *res)
int PQflush(PGconn *conn)
void PQfreemem(void *ptr)
PGnotify * PQnotifies(PGconn *conn)
PGresult * PQprepare(PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
int PQgetline(PGconn *conn, char *buffer, int length)
unsigned char * PQunescapeBytea(const unsigned char *strtext, size_t *retbuflen)
static size_t PQescapeStringInternal(PGconn *conn, char *to, const char *from, size_t length, int *error, int encoding, bool std_strings)
Oid PQftype(const PGresult *res, int field_num)
int PQexitPipelineMode(PGconn *conn)
int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs)
void pqSaveMessageField(PGresult *res, char code, const char *value)
char * PQescapeIdentifier(PGconn *conn, const char *str, size_t len)
static unsigned char * PQescapeByteaInternal(PGconn *conn, const unsigned char *from, size_t from_length, size_t *to_length, bool std_strings, bool use_hex)
static int check_tuple_field_number(const PGresult *res, int tup_num, int field_num)
static void pqSaveWriteError(PGconn *conn)
int PQenterPipelineMode(PGconn *conn)
void pqSetResultError(PGresult *res, PQExpBuffer errorMessage, int offset)
size_t PQescapeStringConn(PGconn *conn, char *to, const char *from, size_t length, int *error)
void pqSaveErrorResult(PGconn *conn)
char *const pgresStatus[]
char * pqResultStrdup(PGresult *res, const char *str)
#define PGRESULT_DATA_BLOCKSIZE
PGresult * PQexecParams(PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
ExecStatusType PQresultStatus(const PGresult *res)
Oid PQparamtype(const PGresult *res, int param_num)
static int check_param_number(const PGresult *res, int param_num)
int pqRowProcessor(PGconn *conn, const char **errmsgp)
PGresult * PQdescribePrepared(PGconn *conn, const char *stmt)
int PQnparams(const PGresult *res)
void PQclear(PGresult *res)
char * PQcmdTuples(PGresult *res)
char * PQresultErrorMessage(const PGresult *res)
static PGresult * PQexecFinish(PGconn *conn)
int PQfformat(const PGresult *res, int field_num)
static void pqAppendCmdQueueEntry(PGconn *conn, PGcmdQueueEntry *entry)
static int PQsendQueryGuts(PGconn *conn, const char *command, const char *stmtName, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
int PQendcopy(PGconn *conn)
static int pqPipelineFlush(PGconn *conn)
int PQputCopyEnd(PGconn *conn, const char *errormsg)
int PQntuples(const PGresult *res)
int PQputnbytes(PGconn *conn, const char *buffer, int nbytes)
int PQputline(PGconn *conn, const char *string)
int PQgetlineAsync(PGconn *conn, char *buffer, int bufsize)
static const PGresult OOM_result
#define PGRESULT_BLOCK_OVERHEAD
int PQputCopyData(PGconn *conn, const char *buffer, int nbytes)
PGresult * PQexecPrepared(PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
static PGcmdQueueEntry * pqAllocCmdQueueEntry(PGconn *conn)
static PGresult * getCopyResult(PGconn *conn, ExecStatusType copytype)
static PGEvent * dupEvents(PGEvent *events, int count, size_t *memSize)
char * PQfname(const PGresult *res, int field_num)
static bool static_std_strings
char * PQescapeLiteral(PGconn *conn, const char *str, size_t len)
void pqInternalNotice(const PGNoticeHooks *hooks, const char *fmt,...)
PGresult * PQdescribePortal(PGconn *conn, const char *portal)
int PQsendDescribePrepared(PGconn *conn, const char *stmt)
PGresult * PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status)
PGresult * PQexec(PGconn *conn, const char *query)
unsigned char * PQescapeByteaConn(PGconn *conn, const unsigned char *from, size_t from_length, size_t *to_length)
static const char hextbl[]
static bool PQexecStart(PGconn *conn)
size_t PQescapeString(char *to, const char *from, size_t length)
int PQconsumeInput(PGconn *conn)
#define ISFIRSTOCTDIGIT(CH)
static void parseInput(PGconn *conn)
char * PQgetvalue(const PGresult *res, int tup_num, int field_num)
Oid PQftable(const PGresult *res, int field_num)
int PQfnumber(const PGresult *res, const char *field_name)
char * PQcmdStatus(PGresult *res)
void pqSaveParameterStatus(PGconn *conn, const char *name, const char *value)
int PQsetnonblocking(PGconn *conn, int arg)
static int PQsendDescribe(PGconn *conn, char desc_type, const char *desc_target)
int PQsendPrepare(PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
#define PGRESULT_SEP_ALLOC_THRESHOLD
int PQfmod(const PGresult *res, int field_num)
void pqClearAsyncResult(PGconn *conn)
int PQgetisnull(const PGresult *res, int tup_num, int field_num)
int PQftablecol(const PGresult *res, int field_num)
static int static_client_encoding
int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len)
int PQsendQuery(PGconn *conn, const char *query)
int PQpipelineSync(PGconn *conn)
char * PQresStatus(ExecStatusType status)
int PQsendDescribePortal(PGconn *conn, const char *portal)
size_t PQresultMemorySize(const PGresult *res)
int PQisBusy(PGconn *conn)
int PQsendQueryPrepared(PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
static void pqPipelineProcessQueue(PGconn *conn)
int PQsendFlushRequest(PGconn *conn)
void * pqResultAlloc(PGresult *res, size_t nBytes, bool isBinary)
char * PQoidStatus(const PGresult *res)
char * PQresultErrorField(const PGresult *res, int fieldcode)
int PQisnonblocking(const PGconn *conn)
PGresult * PQcopyResult(const PGresult *src, int flags)
void * PQresultAlloc(PGresult *res, size_t nBytes)
Oid PQoidValue(const PGresult *res)
static bool pqAddTuple(PGresult *res, PGresAttValue *tup, const char **errmsgp)
char * PQresultVerboseErrorMessage(const PGresult *res, PGVerbosity verbosity, PGContextVisibility show_context)
#define PGRESULT_ALIGN_BOUNDARY
int PQnfields(const PGresult *res)
static int check_field_number(const PGresult *res, int field_num)
PGresult * PQgetResult(PGconn *conn)
PGresult * pqPrepareAsyncResult(PGconn *conn)
int PQfsize(const PGresult *res, int field_num)
static bool PQsendQueryStart(PGconn *conn, bool newQuery)
static const int8 hexlookup[128]
int PQgetCopyData(PGconn *conn, char **buffer, int async)
static void pqRecycleCmdQueueEntry(PGconn *conn, PGcmdQueueEntry *entry)
void PQfreeNotify(PGnotify *notify)
void pqCommandQueueAdvance(PGconn *conn)
int pqPutc(char c, PGconn *conn)
int pqReadData(PGconn *conn)
int pqPutInt(int value, size_t bytes, PGconn *conn)
int pqCheckOutBufferSpace(size_t bytes_needed, PGconn *conn)
int pqFlush(PGconn *conn)
int pqPutMsgStart(char msg_type, PGconn *conn)
int pqWait(int forRead, int forWrite, PGconn *conn)
int pqPutnchar(const char *s, size_t len, PGconn *conn)
int pqPuts(const char *s, PGconn *conn)
void libpq_append_conn_error(PGconn *conn, const char *fmt,...)
int pqPutMsgEnd(PGconn *conn)
void pqBuildErrorMessage3(PQExpBuffer msg, const PGresult *res, PGVerbosity verbosity, PGContextVisibility show_context)
void pqParseInput3(PGconn *conn)
int pqEndcopy3(PGconn *conn)
PGresult * pqFunctionCall3(PGconn *conn, Oid fnid, int *result_buf, int *actual_result_len, int result_is_int, const PQArgBlock *args, int nargs)
int pqGetlineAsync3(PGconn *conn, char *buffer, int bufsize)
int pqGetCopyData3(PGconn *conn, char **buffer, int async)
int pqGetline3(PGconn *conn, char *s, int maxlen)
if(TABLE==NULL||TABLE_index==NULL)
int PQfireResultCreateEvents(PGconn *conn, PGresult *res)
#define PG_COPYRES_TUPLES
struct pg_result PGresult
#define PG_COPYRES_EVENTS
#define PG_COPYRES_NOTICEHOOKS
#define PQ_QUERY_PARAM_MAX_LIMIT
struct pgParameterStatus pgParameterStatus
#define pqClearConnErrorState(conn)
union pgresult_data PGresult_data
#define pqIsnonblocking(conn)
#define OUTBUFFER_THRESHOLD
#define pgHavePendingResult(conn)
static void const char * fmt
Assert(fmt[strlen(fmt) - 1] !='\n')
static void static void status(const char *fmt,...) pg_attribute_printf(1
static rewind_source * source
unsigned char pg_tolower(unsigned char ch)
#define PG_DIAG_SEVERITY_NONLOCALIZED
#define PG_DIAG_MESSAGE_PRIMARY
void initPQExpBuffer(PQExpBuffer str)
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
void termPQExpBuffer(PQExpBuffer str)
#define PQExpBufferBroken(str)
#define PQExpBufferDataBroken(buf)
PQnoticeReceiver noticeRec
PQnoticeProcessor noticeProc
struct PGcmdQueueEntry * next
struct pgMessageField * next
char contents[FLEXIBLE_ARRAY_MEMBER]
struct pgParameterStatus * next
PGTernaryBool in_hot_standby
PGcmdQueueEntry * cmd_queue_recycle
PGcmdQueueEntry * cmd_queue_tail
PGTernaryBool default_transaction_read_only
pgParameterStatus * pstatus
PQExpBufferData errorMessage
PGAsyncStatusType asyncStatus
PGpipelineStatus pipelineStatus
PGNoticeHooks noticeHooks
PGcmdQueueEntry * cmd_queue_head
PGNoticeHooks noticeHooks
char cmdStatus[CMDSTATUS_LEN]
PGMessageField * errFields
PGresParamDesc * paramDescs
ExecStatusType resultStatus
static StringInfoData tmpbuf
int pg_encoding_mblen(int encoding, const char *mbstr)