char *xlogFilePath; /* where we are going to restore to */
char *nextWALFileName; /* the file we need to get from archive */
char *restartWALFileName; /* the file from which we can restart restore */
-char *priorWALFileName; /* the file we need to get from archive */
char WALFilePath[MAXPGPATH * 2]; /* the file path including archive */
char restoreCommand[MAXPGPATH]; /* run this to restore */
char exclusiveCleanupFileName[MAXFNAMELEN]; /* the file we need to get
*/
/*
- * Helper function for pgp_armor. Converts arrays of keys and values into
+ * Helper function for pg_armor. Converts arrays of keys and values into
* plain C arrays, and checks that they don't contain invalid characters.
*/
static int
void px_free(void *p);
#endif
-/* max len of 'type' parms */
-#define PX_MAX_NAMELEN 128
-
/* max salt returned */
#define PX_MAX_SALT_LEN 128
#define BCOUNT (ctxt->c.b64[0] / 8)
#define W(n) (ctxt->m.b32[(n)])
-#define PUTBYTE(x) \
-do { \
- ctxt->m.b8[(COUNT % 64)] = (x); \
- COUNT++; \
- COUNT %= 64; \
- ctxt->c.b64[0] += 8; \
- if (COUNT % 64 == 0) \
- sha1_step(ctxt); \
-} while (0)
-
#define PUTPAD(x) \
do { \
ctxt->m.b8[(COUNT % 64)] = (x); \
/*
* Back into an estimate of the number of retrieved rows. Just in
- * case this is nuts, clamp to at most nrow.
+ * case this is nuts, clamp to at most nrows.
*/
retrieved_rows = clamp_row_est(rows / fpinfo->local_conds_sel);
retrieved_rows = Min(retrieved_rows, nrows);
*/
extern char *sepgsql_get_client_label(void);
extern void sepgsql_init_client_label(void);
-extern char *sepgsql_get_label(Oid relOid, Oid objOid, int32 subId);
+extern char *sepgsql_get_label(Oid classId, Oid objectId, int32 subId);
extern void sepgsql_object_relabel(const ObjectAddress *object,
const char *seclabel);
PG_MODULE_MAGIC;
-/* These must be available to pg_dlsym() */
+/* These must be available to dlsym() */
extern void _PG_init(void);
extern void _PG_output_plugin_init(OutputPluginCallbacks *cb);
It should either be issued when the last string has been sent
to the server using <xref linkend="libpq-PQputline"/> or when the
last string has been received from the server using
- <function>PGgetline</function>. It must be issued or the server
+ <function>PQgetline</function>. It must be issued or the server
will get <quote>out of sync</quote> with the client. Upon return
from this function, the server is ready to receive the next SQL
command. The return value is 0 on successful completion,
effectively drops all the privileges assigned directly to the session user
and to the other roles it is a member of, leaving only the privileges
available to the named role. On the other hand, if the session user role
- has the <literal>NOINHERITS</literal> attribute, <command>SET ROLE</command> drops the
+ has the <literal>NOINHERIT</literal> attribute, <command>SET ROLE</command> drops the
privileges assigned directly to the session user and instead acquires the
privileges available to the named role.
</para>
localityName (alias L)
stateOrProvinceName (alias ST)
organizationName (alias O)
-organizationUnitName (alias OU)
+organizationalUnitName (alias OU)
title
description
initials
conveniently fits in at most 6 bytes.
A compressed posting list is passed around and stored on disk in a
-PackedPostingList struct. The first item in the list is stored uncompressed
+GinPostingList struct. The first item in the list is stored uncompressed
as a regular ItemPointerData, followed by the length of the list in bytes,
followed by the packed items.
}
else
{
- elog(ERROR, "invalid return code from GIN placeToPage method: %d", rc);
+ elog(ERROR, "invalid return code from GIN beginPlaceToPage method: %d", rc);
result = false; /* keep compiler quiet */
}
/*
* Mark all killedItems as dead. We need no additional recheck, because,
- * if page was modified, pageLSN must have changed.
+ * if page was modified, curPageLSN must have changed.
*/
for (i = 0; i < so->numKilled; i++)
{
/*
* Check if the page was deleted after we saw the downlink. There's
- * nothing of interest on a deleted page. Note that we must do this
- * after checking the NSN for concurrent splits! It's possible that
- * the page originally contained some tuples that are visible to us,
- * but was split so that all the visible tuples were moved to another
- * page, and then this page was deleted.
+ * nothing of interest on a deleted page. Note that we must do this after
+ * checking the NSN for concurrent splits! It's possible that the page
+ * originally contained some tuples that are visible to us, but was split
+ * so that all the visible tuples were moved to another page, and then
+ * this page was deleted.
*/
if (GistPageIsDeleted(page))
{
/*
* if the page on which are adding tuples is a page previous to freed
- * overflow page, then update its nextblno.
+ * overflow page, then update its nextblkno.
*/
if (xldata->is_prev_bucket_same_wrt)
{
* _hash_pgaddtup() -- add a tuple to a particular page in the index.
*
* This routine adds the tuple to the page as requested; it does not write out
- * the page. It is an error to call pgaddtup() without pin and write lock on
- * the target buffer.
+ * the page. It is an error to call this function without pin and write lock
+ * on the target buffer.
*
* Returns the offset number at which the tuple was inserted. This function
* is responsible for preserving the condition that tuples in a hash index
TransactionId xid, CommandId cid, int options);
static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
Buffer newbuf, HeapTuple oldtup,
- HeapTuple newtup, HeapTuple old_key_tup,
+ HeapTuple newtup, HeapTuple old_key_tuple,
bool all_visible_cleared, bool new_all_visible_cleared);
static Bitmapset *HeapDetermineModifiedColumns(Relation relation,
Bitmapset *interesting_cols,
/* prototypes for internal routines */
static Buffer vm_readbuf(Relation rel, BlockNumber blkno, bool extend);
-static void vm_extend(Relation rel, BlockNumber nvmblocks);
+static void vm_extend(Relation rel, BlockNumber vm_nblocks);
/*
/* XLOG stuff */
if (wstate->btws_use_wal)
{
- /* We use the heap NEWPAGE record type for this */
+ /* We use the XLOG_FPI record type for this */
log_newpage(&wstate->index->rd_node, MAIN_FORKNUM, blkno, page, true);
}
construction workspace. This is only needed if you have already called
XLogBeginInsert(), but decide to not insert the record after all.
-void XLogEnsureRecordSpace(int max_block_id, int nrdatas)
+void XLogEnsureRecordSpace(int max_block_id, int ndatas)
Normally, the WAL record construction buffers have the following limits:
static bool CLOGPagePrecedes(int page1, int page2);
static void WriteZeroPageXlogRec(int pageno);
static void WriteTruncateXlogRec(int pageno, TransactionId oldestXact,
- Oid oldestXidDb);
+ Oid oldestXactDb);
static void TransactionIdSetPageStatus(TransactionId xid, int nsubxids,
TransactionId *subxids, XidStatus status,
XLogRecPtr lsn, int pageno,
} MultiXactStateData;
/*
- * Last element of OldestMemberMXactID and OldestVisibleMXactId arrays.
+ * Last element of OldestMemberMXactId and OldestVisibleMXactId arrays.
* Valid elements are (1..MaxOldestSlot); element 0 is never used.
*/
#define MaxOldestSlot (MaxBackends + max_prepared_xacts)
return mask;
/*
- * Get the largeobject's ACL from pg_language_metadata
+ * Get the largeobject's ACL from pg_largeobject_metadata
*/
pg_lo_meta = table_open(LargeObjectMetadataRelationId,
AccessShareLock);
pg_catalog.array_upper($1,1),
1) as g(s)';
-CREATE FUNCTION _pg_keysequal(smallint[], smallint[]) RETURNS boolean
- LANGUAGE sql IMMUTABLE PARALLEL SAFE -- intentionally not STRICT, to allow inlining
- AS 'select $1 operator(pg_catalog.<@) $2 and $2 operator(pg_catalog.<@) $1';
-
/* Given an index's OID and an underlying-table column number, return the
* column's position in the index (NULL if not there) */
CREATE FUNCTION _pg_index_position(oid, smallint) RETURNS int
/*
* This struct maps the string object types as returned by
- * getObjectTypeDescription into ObjType enum values. Note that some enum
+ * getObjectTypeDescription into ObjectType enum values. Note that some enum
* values can be obtained by different names, and that some string object types
* do not have corresponding values in the output enum. The user of this map
* must be careful to test for invalid values being returned.
* Working state for COPY FROM
*/
AttrNumber num_defaults;
- FmgrInfo oid_in_function;
FmgrInfo *in_functions; /* array of input functions for each attrs */
Oid *typioparams; /* array of element types for in_functions */
int *defmap; /* array of default att numbers */
/*
* The set of strings accepted here should match up with the
- * grammar's opt_boolean production.
+ * grammar's opt_boolean_or_string production.
*/
if (pg_strcasecmp(sval, "true") == 0)
return true;
}
/*
- * grammar only allows OptimizableStmt, so this check should be redundant
+ * grammar only allows PreparableStmt, so this check should be redundant
*/
switch (query->commandType)
{
}
/*
- * vacuum_set_xid_limits() -- compute oldest-Xmin and freeze cutoff points
+ * vacuum_set_xid_limits() -- compute oldestXmin and freeze cutoff points
*
* The output parameters are:
* - oldestXmin is the cutoff value used to distinguish whether tuples are
bool resulttypeByVal;
bool plain_agg; /* is it just a plain aggregate function? */
- int aggno; /* if so, index of its PerAggData */
+ int aggno; /* if so, index of its WindowStatePerAggData */
WindowObject winobj; /* object used in window function API */
} WindowStatePerFuncData;
resulttypeByVal,
transtypeByVal;
- int wfuncno; /* index of associated PerFuncData */
+ int wfuncno; /* index of associated WindowStatePerFuncData */
/* Context holding transition value and possibly other subsidiary data */
MemoryContext aggcontext; /* may be private, or winstate->aggcontext */
* StreamClose - Close a client/backend connection
* TouchSocketFiles - Protect socket files against /tmp cleaners
* pq_init - initialize libpq at backend startup
- * pq_comm_reset - reset libpq during error recovery
- * pq_close - shutdown libpq at backend exit
+ * socket_comm_reset - reset libpq during error recovery
+ * socket_close - shutdown libpq at backend exit
*
* low-level I/O:
* pq_getbytes - get a known number of bytes from connection
}
/*
- * Serialize a paramListInfo structure into caller-provided storage.
+ * Serialize a ParamListInfo structure into caller-provided storage.
*
* We write the number of parameters first, as a 4-byte integer, and then
* write details for each parameter in turn. The details for each parameter
PagetableEntry *page;
int ntuples;
- /* In ONE_PAGE state, we don't allocate an spages[] array */
+ /* In TBM_ONE_PAGE state, we don't allocate an spages[] array */
if (tbm->status == TBM_ONE_PAGE)
page = &tbm->entry1;
else
static int
linear_rand(PlannerInfo *root, int pool_size, double bias)
{
- double index; /* index between 0 and pop_size */
+ double index; /* index between 0 and pool_size */
double max = (double) pool_size;
/*
* 2) If there are no empty sets and only unsortable sets, then the
* rollups list will be empty (and thus l_start == NULL), and
* group_pathkeys will be NIL; we must ensure that the vacuously-true
- * pathkeys_contain_in test doesn't cause us to crash.
+ * pathkeys_contained_in test doesn't cause us to crash.
*/
if (l_start != NULL &&
pathkeys_contained_in(root->group_pathkeys, path->pathkeys))
* a regular aggregation node would, plus any aggregates used in HAVING;
* except that the Aggref nodes should be marked as partial aggregates.
*
- * In addition, we'd better emit any Vars and PlaceholderVars that are
+ * In addition, we'd better emit any Vars and PlaceHolderVars that are
* used outside of Aggrefs in the aggregation tlist and HAVING. (Presumably,
* these would be Vars that are grouped by or used in grouping expressions.)
*
/*
* LookupOperWithArgs
* Like LookupOperName, but the argument types are specified by
- * a ObjectWithArg node.
+ * a ObjectWithArgs node.
*/
Oid
LookupOperWithArgs(ObjectWithArgs *oper, bool noError)
}
/* ----------
- * pgstat_recv_resetshared() -
+ * pgstat_recv_resetsharedcounter() -
*
* Reset some shared statistics of the cluster.
* ----------
#define NWBDRY 'W' /* non-word-boundary constraint */
#define SBEGIN 'A' /* beginning of string (even if not BOL) */
#define SEND 'Z' /* end of string (even if not EOL) */
-#define PREFER 'P' /* length preference */
/* is an arc colored, and hence on a color chain? */
#define COLORED(a) \
snap->subxip[i++] = txn->xid;
/*
- * nsubxcnt isn't decreased when subtransactions abort, so count manually.
+ * subxcnt isn't decreased when subtransactions abort, so count manually.
* Since it's an upper boundary it is safe to use it for the allocation
* above.
*/
&found);
}
- /* Register and initialize fields of ProcLWLockTranche */
LWLockRegisterTranche(LWTRANCHE_PROC, "proc");
}
pg_atomic_read_u64(&mq->mq_bytes_written) + n);
}
-/* Shim for on_dsm_callback. */
+/* Shim for on_dsm_detach callback. */
static void
shm_mq_detach_callback(dsm_segment *seg, Datum arg)
{
/*
* We can't acquire the lock immediately. If caller specified no
- * blocking, remove useless table entries and return NOT_AVAIL without
- * waiting.
+ * blocking, remove useless table entries and return
+ * LOCKACQUIRE_NOT_AVAIL without waiting.
*/
if (dontWait)
{
* These configuration variables are used to set the predicate lock table size
* and to control promotion of predicate locks to coarser granularity in an
* attempt to degrade performance (mostly as false positive serialization
- * failure) gracefully in the face of memory pressurel
+ * failure) gracefully in the face of memory pressure.
*/
int max_predicate_locks_per_xact; /* set by guc.c */
int max_predicate_locks_per_relation; /* set by guc.c */
}
/*
- * PreCommit_CheckForSerializableConflicts
+ * PreCommit_CheckForSerializationFailure
* Check for dangerous structures in a serializable transaction
* at commit.
*
/*
* Wrapper functions for the 1 and 3 argument variants of pg_read_file_v2()
- * and pg_binary_read_file().
+ * and pg_read_binary_file().
*
* These are necessary to pass the sanity check in opr_sanity, which checks
* that all built-in functions that share the implementing C function take
List *windowTList; /* targetlist for resolving WINDOW clause */
int prettyFlags; /* enabling of pretty-print functions */
int wrapColumn; /* max line length, or -1 for no limit */
- int indentLevel; /* current indent level for prettyprint */
+ int indentLevel; /* current indent level for pretty-print */
bool varprefix; /* true to print prefixes on Vars */
ParseExprKind special_exprkind; /* set only for exprkinds needing special
* handling */
*
* For each block, we maintain pointer to the first free chunk - this is quite
* cheap and allows us to skip all the preceding used chunks, eliminating
- * a significant number of lookups in many common usage patters. In the worst
+ * a significant number of lookups in many common usage patterns. In the worst
* case this performs as if the pointer was not maintained.
*
* We cache the freelist index for the blocks with the fewest free chunks
/*
* During normal commit processing, we call ProcArrayEndTransaction() to
- * reset the PgXact->xmin. That call happens prior to the call to
+ * reset the MyPgXact->xmin. That call happens prior to the call to
* AtEOXact_Snapshot(), so we need not touch xmin here at all.
*/
if (resetXmin)
err = WSAStartup(MAKEWORD(2, 2), &wsaData);
#endif
- /* for best results, this code should match parse_hba() */
+ /* for best results, this code should match parse_hba_line() */
hints.ai_flags = AI_NUMERICHOST;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = 0;
#define oidcmp(x,y) ( ((x) < (y) ? -1 : ((x) > (y)) ? 1 : 0) )
-#define oideq(x,y) ( (x) == (y) )
-#define oidle(x,y) ( (x) <= (y) )
-#define oidge(x,y) ( (x) >= (y) )
-#define oidzero(x) ( (x) == 0 )
/*
* The data structures used to store system catalog information. Every
static void usage(const char *progname);
-typedef struct option optType;
-
int
main(int argc, char **argv)
{
*
* On entry, ControlFile.checkPointCopy.redo and ControlFile.xlog_seg_size
* are assumed valid (note that we allow the old xlog seg size to differ
- * from what we're using). On exit, newXlogId and newXlogSeg are set to
- * suitable values for the beginning of replacement WAL (in our seg size).
+ * from what we're using). On exit, newXlogSegNo is set to suitable
+ * value for the beginning of replacement WAL (in our seg size).
*/
static void
FindEndOfXLOG(void)
extern bool describeRoles(const char *pattern, bool verbose, bool showSystem);
/* \drds */
-extern bool listDbRoleSettings(const char *pattern1, const char *pattern2);
+extern bool listDbRoleSettings(const char *pattern, const char *pattern2);
/* \z (or \dp) */
extern bool permissionsList(const char *pattern);
if (pg_wcscmp(test->output, result) != 0)
{
- printf("FAILURE (Normalizationdata.txt line %d):\n", test->linenum);
+ printf("FAILURE (NormalizationTest.txt line %d):\n", test->linenum);
printf("input:\t%s\n", print_wchar_str(test->input));
printf("expected:\t%s\n", print_wchar_str(test->output));
printf("got\t%s\n", print_wchar_str(result));
extern void CommitTsShmemInit(void);
extern void BootStrapCommitTs(void);
extern void StartupCommitTs(void);
-extern void CommitTsParameterChange(bool xlrecvalue, bool pgcontrolvalue);
+extern void CommitTsParameterChange(bool newvalue, bool oldvalue);
extern void CompleteCommitTsInitialization(void);
extern void ShutdownCommitTs(void);
extern void CheckPointCommitTs(void);
bool oneCol; /* true if single-column index */
/*
- * origTupDesc is the nominal tuple descriptor of the index, ie, the i'th
+ * origTupdesc is the nominal tuple descriptor of the index, ie, the i'th
* attribute shows the key type (not the input data type!) of the i'th
* index column. In a single-column index this describes the actual leaf
* index tuples. In a multi-column index, the actual leaf tuples contain
/* ginpostinglist.c */
-extern GinPostingList *ginCompressPostingList(const ItemPointer ptrs, int nptrs,
+extern GinPostingList *ginCompressPostingList(const ItemPointer ipd, int nipd,
int maxsize, int *nwritten);
extern int ginPostingListDecodeAllSegmentsToTbm(GinPostingList *ptr, int totalsize, TIDBitmap *tbm);
uint32 hashm_maxbucket; /* ID of maximum bucket in use */
uint32 hashm_highmask; /* mask to modulo into entire table */
uint32 hashm_lowmask; /* mask to modulo into lower half of table */
- uint32 hashm_ovflpoint; /* splitpoint from which ovflpgs being
+ uint32 hashm_ovflpoint; /* splitpoint from which ovflpage being
* allocated */
uint32 hashm_firstfree; /* lowest-number free ovflpage (bit#) */
uint32 hashm_nmaps; /* number of bitmap pages */
extern const char *btree_identify(uint8 info);
extern void btree_mask(char *pagedata, BlockNumber blkno);
-#endif /* NBXLOG_H */
+#endif /* NBTXLOG_H */
extern void XLogBeginInsert(void);
extern void XLogSetRecordFlags(uint8 flags);
extern XLogRecPtr XLogInsert(RmgrId rmid, uint8 info);
-extern void XLogEnsureRecordSpace(int nbuffers, int ndatas);
+extern void XLogEnsureRecordSpace(int max_block_id, int ndatas);
extern void XLogRegisterData(char *data, int len);
extern void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags);
extern void XLogRegisterBlock(uint8 block_id, RelFileNode *rnode,
*
* The rule for developers is: if you commit a change that requires
* an initdb, you should update the catalog version number (as well as
- * notifying the pghackers mailing list, which has been the informal
- * practice for a long time).
+ * notifying the pgsql-hackers mailing list, which has been the
+ * informal practice for a long time).
*
* The catalog version number is placed here since modifying files in
* include/catalog is the most common kind of initdb-forcing change.
extern ObjectAddress ExecAlterExtensionStmt(ParseState *pstate, AlterExtensionStmt *stmt);
extern ObjectAddress ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt,
- ObjectAddress *objAddress);
+ ObjectAddress *objAddr);
extern Oid get_extension_oid(const char *extname, bool missing_ok);
extern char *get_extension_name(Oid ext_oid);
Oid relId, Oid oldRelId, void *arg);
extern void RangeVarCallbackOwnsRelation(const RangeVar *relation,
- Oid relId, Oid oldRelId, void *noCatalogs);
+ Oid relId, Oid oldRelId, void *arg);
extern bool PartConstraintImpliedByRelConstraint(Relation scanrel,
List *partConstraint);
/* for EEOP_WINDOW_FUNC */
struct
{
- /* out-of-line state, modified by nodeWindowFunc.c */
+ /* out-of-line state, modified by nodeWindowAgg.c */
WindowFuncExprState *wfstate;
} window_func;
#define PG_ENCODING_BE_LAST PG_KOI8U
/*
- * Please use these tests before access to pg_encconv_tbl[]
+ * Please use these tests before access to pg_enc2name_tbl[]
* or to other places...
*/
#define PG_VALID_BE_ENCODING(_enc) \
*
*-------------------------------------------------------------------------
*/
-#ifndef PARSER_FUNC_H
-#define PARSER_FUNC_H
+#ifndef PARSE_FUNC_H
+#define PARSE_FUNC_H
#include "catalog/namespace.h"
#include "parser/parse_node.h"
}
/*
- * pg_atomic_test_and_set_flag - TAS()
+ * pg_atomic_test_set_flag - TAS()
*
* Returns true if the flag has successfully been set, false otherwise.
*
*
* This is a pointer to an item within a disk page of a known file
* (for example, a cross-link from an index to its parent table).
- * blkid tells us which block, posid tells us which entry in the linp
- * (ItemIdData) array we want.
+ * ip_blkid tells us which block, ip_posid tells us which entry in
+ * the linp (ItemIdData) array we want.
*
* Note: because there is an item pointer in each tuple header and index
* tuple header on disk, it's very important not to waste space with
#define InvalidOffsetNumber ((OffsetNumber) 0)
#define FirstOffsetNumber ((OffsetNumber) 1)
#define MaxOffsetNumber ((OffsetNumber) (BLCKSZ / sizeof(ItemIdData)))
-#define OffsetNumberMask (0xffff) /* valid uint16 bits */
/* ----------------
* support macros
extern void BecomeLockGroupLeader(void);
extern bool BecomeLockGroupMember(PGPROC *leader, int pid);
-#endif /* PROC_H */
+#endif /* _PROC_H_ */
} JsonSemAction;
/*
- * parse_json will parse the string in the lex calling the
+ * pg_parse_json will parse the string in the lex calling the
* action functions in sem at the appropriate points. It is
* up to them to keep what state they need in semstate. If they
* need access to the state of the lexer, then its pointer
/*------
* create a list of variables
*
- * The variables are listed with input variables preceding outputvariables
- * The end of each group is marked by an end marker. per variable we list:
+ * The variables are listed with input variables preceding output
+ * variables. The end of each group is marked by an end marker.
+ * Per variable we list:
*
* type - as defined in ecpgtype.h
* value - where to store the data
/*
* evil[tm] hack: if we read the pgtypes_date_months and haven't
- * found a match, reset list to point to pgtypes_date_months_short
+ * found a match, reset list to point to months (abbreviations)
* and reset the counter variable i
*/
if (list == pgtypes_date_months)
* PQPING_NO_RESPONSE. This result could be somewhat misleading for a
* pre-7.4 server, since it won't send back a SQLSTATE, but those are long
* out of support. Another corner case where the server could return a
- * failure without a SQLSTATE is fork failure, but NO_RESPONSE isn't
- * totally unreasonable for that anyway. We expect that every other
+ * failure without a SQLSTATE is fork failure, but PQPING_NO_RESPONSE
+ * isn't totally unreasonable for that anyway. We expect that every other
* failure case in a modern server will produce a report with a SQLSTATE.
*
* NOTE: whenever we get around to making libpq generate SQLSTATEs for
* PQfreemem - safely frees memory allocated
*
* Needed mostly by Win32, unless multithreaded DLL (/MD in VC6)
- * Used for freeing memory from PQescapeByte()a/PQunescapeBytea()
+ * Used for freeing memory from PQescapeBytea()/PQunescapeBytea()
*/
void
PQfreemem(void *ptr)
* miscellaneous useful functions
*
* The communication routines here are analogous to the ones in
- * backend/libpq/pqcomm.c and backend/libpq/pqcomprim.c, but operate
+ * backend/libpq/pqcomm.c and backend/libpq/pqformat.c, but operate
* in the considerably different environment of the frontend libpq.
* In particular, we work with a bare nonblock-mode socket, rather than
* a stdio stream, so that we can avoid unwanted blocking of the application.
extern void PQprintTuples(const PGresult *res,
FILE *fout, /* output stream */
- int printAttName, /* print attribute names */
- int terseOutput, /* delimiter bars */
- int width); /* width of column, if 0, use variable
- * width */
+ int PrintAttNames, /* print attribute names */
+ int TerseOutput, /* delimiter bars */
+ int colWidth); /* width of column, if 0, use
+ * variable width */
/* === in fe-lobj.c === */
int ntups;
int numAttributes;
PGresAttDesc *attDescs;
- PGresAttValue **tuples; /* each PGresTuple is an array of
+ PGresAttValue **tuples; /* each PGresult tuple is an array of
* PGresAttValue's */
int tupArrSize; /* allocated size of tuples array */
int numParameters;
PGQUERY_DESCRIBE /* Describe Statement or Portal */
} PGQueryClass;
-/* PGSetenvStatusType defines the state of the PQSetenv state machine */
+/* PGSetenvStatusType defines the state of the pqSetenv state machine */
+
/* (this is used only for 2.0-protocol connections) */
typedef enum
{
plpgsql_free_function_memory(func);
}
-/* exported so we can call it from plpgsql_init() */
+/* exported so we can call it from _PG_init() */
void
plpgsql_HashTableInit(void)
{
/*
* PLpgSQL_stmt_forq represents a FOR statement running over a SQL query.
* It is the common supertype of PLpgSQL_stmt_fors, PLpgSQL_stmt_forc
- * and PLpgSQL_dynfors.
+ * and PLpgSQL_stmt_dynfors.
*/
typedef struct PLpgSQL_stmt_forq
{
*mp = '\0';
if (mp > (mrc + mlen))
- elog(FATAL, "buffer overrun in PLy_munge_source");
+ elog(FATAL, "buffer overrun in PLy_procedure_munge_source");
return mrc;
}
check: all
$(pg_isolation_regress_check) --schedule=$(srcdir)/isolation_schedule
-# Versions of the check tests that include the prepared_transactions test
+# Versions of the check tests that include the prepared-transactions test
# It only makes sense to run these if set up to use prepared transactions,
# via TEMP_CONFIG for the check case, or via the postgresql.conf for the
# installcheck case.
if ($filter eq "LIBOBJS")
{
no warnings qw(once);
- if (grep(/$p/, @main::pgportfiles, @main::pgcommonfiles)
- == 1)
+ if (grep(/$p/, @main::pgportfiles) == 1)
{
$p =~ s/\.c/\.o/;
$matches .= $p . " ";
projects / postgresql.git / commitdiff