rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Another pgindent run with updated typedefs.

This commit is contained in:
Bruce Momjian 2003-08-08 21:42:59 +00:00
parent 0e2b12bd96
commit 46785776c4
109 changed files with 811 additions and 808 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
contrib/tsearch2/snowball/english_stem.c
View File

@ -1094,12 +1094,14 @@ lab0:
return 1;
}
extern struct SN_env *english_create_env(void)
extern struct SN_env *
english_create_env(void)
{
return SN_create_env(0, 2, 1);
}
extern void english_close_env(struct SN_env * z)
extern void
english_close_env(struct SN_env * z)
{
SN_close_env(z);
}

6
contrib/tsearch2/snowball/russian_stem.c
View File

@ -753,12 +753,14 @@ lab0:
return 1;
}
extern struct SN_env *russian_create_env(void)
extern struct SN_env *
russian_create_env(void)
{
return SN_create_env(0, 2, 0);
}
extern void russian_close_env(struct SN_env * z)
extern void
russian_close_env(struct SN_env * z)
{
SN_close_env(z);
}

3
contrib/tsearch2/snowball/utilities.c
View File

@ -19,7 +19,8 @@ create_s(void)
return p;
}
extern void lose_s(symbol * p)
extern void
lose_s(symbol * p)
{
free((char *) p - HEAD);
}

8
contrib/vacuumlo/vacuumlo.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.23 2003/08/08 20:20:49 momjian Exp $
* $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.24 2003/08/08 21:41:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -149,9 +149,9 @@ vacuumlo(char *database, struct _param * param)
*
* NOTE: we ignore system tables and temp tables by the expedient of
* rejecting tables in schemas named 'pg_*'. In particular, the temp
* table formed above is ignored, and pg_largeobject will be too.
* If either of these were scanned, obviously we'd end up with nothing
* to delete...
* table formed above is ignored, and pg_largeobject will be too. If
* either of these were scanned, obviously we'd end up with nothing to
* delete...
*
* NOTE: the system oid column is ignored, as it has attnum < 1. This
* shouldn't matter for correctness, but it saves time.

4
src/backend/access/index/indexam.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.69 2003/08/04 02:39:57 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.70 2003/08/08 21:41:25 momjian Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relation OID
@ -632,7 +632,7 @@ index_bulk_delete(Relation indexRelation,
*/
IndexBulkDeleteResult *
index_vacuum_cleanup(Relation indexRelation,
IndexVacuumCleanupInfo * info,
IndexVacuumCleanupInfo *info,
IndexBulkDeleteResult *stats)
{
RegProcedure procedure;

11
src/backend/access/nbtree/nbtpage.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.68 2003/08/04 02:39:57 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.69 2003/08/08 21:41:27 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
@ -1110,11 +1110,10 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
_bt_wrtbuf(rel, lbuf);
/*
* If parent became half dead, recurse to try to delete it.
* Otherwise, if right sibling is empty and is now the last child of
* the parent, recurse to try to delete it. (These cases cannot apply
* at the same time, though the second case might itself recurse to
* the first.)
* If parent became half dead, recurse to try to delete it. Otherwise,
* if right sibling is empty and is now the last child of the parent,
* recurse to try to delete it. (These cases cannot apply at the same
* time, though the second case might itself recurse to the first.)
*/
if (parent_half_dead)
{

8
src/backend/access/nbtree/nbtsearch.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.79 2003/08/04 02:39:57 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.80 2003/08/08 21:41:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -951,9 +951,9 @@ _bt_walk_left(Relation rel, Buffer buf)
/*
* If this isn't the page we want, walk right till we find what we
* want --- but go no more than four hops (an arbitrary limit).
* If we don't find the correct page by then, the most likely bet
* is that the original page got deleted and isn't in the sibling
* want --- but go no more than four hops (an arbitrary limit). If
* we don't find the correct page by then, the most likely bet is
* that the original page got deleted and isn't in the sibling
* chain at all anymore, not that its left sibling got split more
* than four times.
*

2
src/backend/access/nbtree/nbtxlog.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.5 2003/08/04 02:39:57 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.6 2003/08/08 21:41:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/backend/access/transam/slru.c
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Header: /cvsroot/pgsql/src/backend/access/transam/slru.c,v 1.5 2003/08/08 14:39:45 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/access/transam/slru.c,v 1.6 2003/08/08 21:41:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/

8
src/backend/access/transam/xact.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.151 2003/08/04 02:39:57 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.152 2003/08/08 21:41:28 momjian Exp $
*
* NOTES
* Transaction aborts can now occur two ways:
@ -954,9 +954,9 @@ CommitTransaction(void)
*
* The ordering of operations is not entirely random. The idea is:
* release resources visible to other backends (eg, files, buffer
* pins); then release locks; then release backend-local resources.
* We want to release locks at the point where any backend waiting for
* us will see our transaction as being fully cleaned up.
* pins); then release locks; then release backend-local resources. We
* want to release locks at the point where any backend waiting for us
* will see our transaction as being fully cleaned up.
*/
smgrDoPendingDeletes(true);

6
src/backend/commands/cluster.c
View File

@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.114 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.115 2003/08/08 21:41:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -63,7 +63,7 @@ typedef struct
} RelToCluster;
static void cluster_rel(RelToCluster * rv, bool recheck);
static void cluster_rel(RelToCluster *rv, bool recheck);
static Oid make_new_heap(Oid OIDOldHeap, const char *NewName);
static void copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex);
static List *get_indexattr_list(Relation OldHeap, Oid OldIndex);
@ -248,7 +248,7 @@ cluster(ClusterStmt *stmt)
* them incrementally while we load the table.
*/
static void
cluster_rel(RelToCluster * rvtc, bool recheck)
cluster_rel(RelToCluster *rvtc, bool recheck)
{
Relation OldHeap,
OldIndex;

2
src/backend/commands/copy.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.207 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.208 2003/08/08 21:41:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/

6
src/backend/commands/explain.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994-5, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.113 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.114 2003/08/08 21:41:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -47,7 +47,7 @@ static void ExplainOneQuery(Query *query, ExplainStmt *stmt,
TupOutputState *tstate);
static double elapsed_time(struct timeval * starttime);
static void explain_outNode(StringInfo str,
Plan *plan, PlanState * planstate,
Plan *plan, PlanState *planstate,
Plan *outer_plan,
int indent, ExplainState *es);
static void show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
@ -313,7 +313,7 @@ elapsed_time(struct timeval * starttime)
*/
static void
explain_outNode(StringInfo str,
Plan *plan, PlanState * planstate,
Plan *plan, PlanState *planstate,
Plan *outer_plan,
int indent, ExplainState *es)
{

4
src/backend/commands/portalcmds.c
View File

@ -14,7 +14,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.22 2003/08/06 17:46:45 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.23 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -36,7 +36,7 @@
* Execute SQL DECLARE CURSOR command.
*/
void
PerformCursorOpen(DeclareCursorStmt * stmt)
PerformCursorOpen(DeclareCursorStmt *stmt)
{
List *rewritten;
Query *query;

4
src/backend/commands/prepare.c
View File

@ -10,7 +10,7 @@
* Copyright (c) 2002-2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/prepare.c,v 1.22 2003/08/04 00:43:16 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/prepare.c,v 1.23 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -412,7 +412,7 @@ FetchPreparedStatementParams(const char *stmt_name)
* Note: the result is created or copied into current memory context.
*/
TupleDesc
FetchPreparedStatementResultDesc(PreparedStatement * stmt)
FetchPreparedStatementResultDesc(PreparedStatement *stmt)
{
Query *query;

4
src/backend/commands/sequence.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.101 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.102 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -302,7 +302,7 @@ DefineSequence(CreateSeqStmt *seq)
* Modify the defition of a sequence relation
*/
void
AlterSequence(AlterSeqStmt * stmt)
AlterSequence(AlterSeqStmt *stmt)
{
SeqTable elm;
Relation seqrel;

2
src/backend/commands/tablecmds.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.78 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.79 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/backend/commands/trigger.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.155 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.156 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/backend/commands/typecmds.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.42 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.43 2003/08/08 21:41:32 momjian Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the

8
src/backend/executor/execAmi.c
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.74 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.75 2003/08/08 21:41:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -48,7 +48,7 @@
* ----------------------------------------------------------------
*/
void
ExecReScan(PlanState * node, ExprContext *exprCtxt)
ExecReScan(PlanState *node, ExprContext *exprCtxt)
{
/* If collecting timing stats, update them */
if (node->instrument)
@ -177,7 +177,7 @@ ExecReScan(PlanState * node, ExprContext *exprCtxt)
* Marks the current scan position.
*/
void
ExecMarkPos(PlanState * node)
ExecMarkPos(PlanState *node)
{
switch (nodeTag(node))
{
@ -218,7 +218,7 @@ ExecMarkPos(PlanState * node)
* restores the scan position previously saved with ExecMarkPos()
*/
void
ExecRestrPos(PlanState * node)
ExecRestrPos(PlanState *node)
{
switch (nodeTag(node))
{

6
src/backend/executor/execGrouping.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execGrouping.c,v 1.6 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execGrouping.c,v 1.7 2003/08/08 21:41:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -296,7 +296,7 @@ BuildTupleHashTable(int numCols, AttrNumber *keyColIdx,
Assert(entrysize >= sizeof(TupleHashEntryData));
tabsize = sizeof(TupleHashTableData) +
(nbuckets - 1) * sizeof(TupleHashEntry);
(nbuckets - 1) *sizeof(TupleHashEntry);
hashtable = (TupleHashTable) MemoryContextAllocZero(tablecxt, tabsize);
hashtable->numCols = numCols;
@ -411,7 +411,7 @@ LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
* Iterator state must be initialized with ResetTupleHashIterator() macro.
*/
TupleHashEntry
ScanTupleHashTable(TupleHashTable hashtable, TupleHashIterator * state)
ScanTupleHashTable(TupleHashTable hashtable, TupleHashIterator *state)
{
TupleHashEntry entry;

8
src/backend/executor/execMain.c
View File

@ -26,7 +26,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.215 2003/08/06 17:46:45 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.216 2003/08/08 21:41:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -68,7 +68,7 @@ static void initResultRelInfo(ResultRelInfo *resultRelInfo,
Index resultRelationIndex,
List *rangeTable,
CmdType operation);
static TupleTableSlot *ExecutePlan(EState *estate, PlanState * planstate,
static TupleTableSlot *ExecutePlan(EState *estate, PlanState *planstate,
CmdType operation,
long numberTuples,
ScanDirection direction,
@ -895,7 +895,7 @@ initResultRelInfo(ResultRelInfo *resultRelInfo,
* ----------------------------------------------------------------
*/
void
ExecEndPlan(PlanState * planstate, EState *estate)
ExecEndPlan(PlanState *planstate, EState *estate)
{
ResultRelInfo *resultRelInfo;
int i;
@ -965,7 +965,7 @@ ExecEndPlan(PlanState * planstate, EState *estate)
*/
static TupleTableSlot *
ExecutePlan(EState *estate,
PlanState * planstate,
PlanState *planstate,
CmdType operation,
long numberTuples,
ScanDirection direction,

6
src/backend/executor/execProcnode.c
View File

@ -12,7 +12,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.39 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.40 2003/08/08 21:41:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -268,7 +268,7 @@ ExecInitNode(Plan *node, EState *estate)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecProcNode(PlanState * node)
ExecProcNode(PlanState *node)
{
TupleTableSlot *result;
@ -484,7 +484,7 @@ ExecCountSlotsNode(Plan *node)
* ----------------------------------------------------------------
*/
void
ExecEndNode(PlanState * node)
ExecEndNode(PlanState *node)
{
List *subp;

88
src/backend/executor/execQual.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.140 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.141 2003/08/08 21:41:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -50,53 +50,53 @@
/* static function decls */
static Datum ExecEvalAggref(AggrefExprState * aggref,
static Datum ExecEvalAggref(AggrefExprState *aggref,
ExprContext *econtext,
bool *isNull);
static Datum ExecEvalArrayRef(ArrayRefExprState * astate,
static Datum ExecEvalArrayRef(ArrayRefExprState *astate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
static Datum ExecEvalParam(Param *expression, ExprContext *econtext,
bool *isNull);
static Datum ExecEvalFunc(FuncExprState * fcache, ExprContext *econtext,
static Datum ExecEvalFunc(FuncExprState *fcache, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalOper(FuncExprState * fcache, ExprContext *econtext,
static Datum ExecEvalOper(FuncExprState *fcache, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalDistinct(FuncExprState * fcache, ExprContext *econtext,
static Datum ExecEvalDistinct(FuncExprState *fcache, ExprContext *econtext,
bool *isNull);
static Datum ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
static Datum ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
ExprContext *econtext, bool *isNull);
static ExprDoneCond ExecEvalFuncArgs(FunctionCallInfo fcinfo,
List *argList, ExprContext *econtext);
static Datum ExecEvalNot(BoolExprState * notclause, ExprContext *econtext,
static Datum ExecEvalNot(BoolExprState *notclause, ExprContext *econtext,
bool *isNull);
static Datum ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext,
static Datum ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext,
bool *isNull);
static Datum ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext,
static Datum ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext,
bool *isNull);
static Datum ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
static Datum ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalArray(ArrayExprState * astate,
static Datum ExecEvalArray(ArrayExprState *astate,
ExprContext *econtext,
bool *isNull);
static Datum ExecEvalCoalesce(CoalesceExprState * coalesceExpr,
static Datum ExecEvalCoalesce(CoalesceExprState *coalesceExpr,
ExprContext *econtext,
bool *isNull);
static Datum ExecEvalNullIf(FuncExprState * nullIfExpr, ExprContext *econtext,
static Datum ExecEvalNullIf(FuncExprState *nullIfExpr, ExprContext *econtext,
bool *isNull);
static Datum ExecEvalNullTest(GenericExprState * nstate,
static Datum ExecEvalNullTest(GenericExprState *nstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalBooleanTest(GenericExprState * bstate,
static Datum ExecEvalBooleanTest(GenericExprState *bstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalCoerceToDomain(CoerceToDomainState * cstate,
static Datum ExecEvalCoerceToDomain(CoerceToDomainState *cstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
static Datum ExecEvalCoerceToDomainValue(CoerceToDomainValue *conVal,
ExprContext *econtext, bool *isNull);
static Datum ExecEvalFieldSelect(GenericExprState * fstate,
static Datum ExecEvalFieldSelect(GenericExprState *fstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
@ -127,7 +127,7 @@ static Datum ExecEvalFieldSelect(GenericExprState * fstate,
*----------
*/
static Datum
ExecEvalArrayRef(ArrayRefExprState * astate,
ExecEvalArrayRef(ArrayRefExprState *astate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -301,7 +301,7 @@ ExecEvalArrayRef(ArrayRefExprState * astate,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalAggref(AggrefExprState * aggref, ExprContext *econtext, bool *isNull)
ExecEvalAggref(AggrefExprState *aggref, ExprContext *econtext, bool *isNull)
{
if (econtext->ecxt_aggvalues == NULL) /* safety check */
elog(ERROR, "no aggregates in this expression context");
@ -606,7 +606,7 @@ GetAttributeByName(TupleTableSlot *slot, char *attname, bool *isNull)
* init_fcache - initialize a FuncExprState node during first use
*/
void
init_fcache(Oid foid, FuncExprState * fcache, MemoryContext fcacheCxt)
init_fcache(Oid foid, FuncExprState *fcache, MemoryContext fcacheCxt)
{
AclResult aclresult;
@ -679,7 +679,7 @@ ExecEvalFuncArgs(FunctionCallInfo fcinfo,
* Evaluate the arguments to a function and then the function itself.
*/
Datum
ExecMakeFunctionResult(FuncExprState * fcache,
ExecMakeFunctionResult(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -882,7 +882,7 @@ ExecMakeFunctionResult(FuncExprState * fcache,
* object. (If function returns an empty set, we just return NULL instead.)
*/
Tuplestorestate *
ExecMakeTableFunctionResult(ExprState * funcexpr,
ExecMakeTableFunctionResult(ExprState *funcexpr,
ExprContext *econtext,
TupleDesc expectedDesc,
TupleDesc *returnDesc)
@ -1159,7 +1159,7 @@ ExecMakeTableFunctionResult(ExprState * funcexpr,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalFunc(FuncExprState * fcache,
ExecEvalFunc(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -1182,7 +1182,7 @@ ExecEvalFunc(FuncExprState * fcache,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalOper(FuncExprState * fcache,
ExecEvalOper(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -1212,7 +1212,7 @@ ExecEvalOper(FuncExprState * fcache,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalDistinct(FuncExprState * fcache,
ExecEvalDistinct(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull)
{
@ -1278,7 +1278,7 @@ ExecEvalDistinct(FuncExprState * fcache,
* the result is known.
*/
static Datum
ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
ExprContext *econtext, bool *isNull)
{
ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) sstate->fxprstate.xprstate.expr;
@ -1431,7 +1431,7 @@ ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalNot(BoolExprState * notclause, ExprContext *econtext, bool *isNull)
ExecEvalNot(BoolExprState *notclause, ExprContext *econtext, bool *isNull)
{
ExprState *clause;
Datum expr_value;
@ -1459,7 +1459,7 @@ ExecEvalNot(BoolExprState * notclause, ExprContext *econtext, bool *isNull)
* ----------------------------------------------------------------
*/
static Datum
ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext, bool *isNull)
ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
List *clause;
@ -1507,7 +1507,7 @@ ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext, bool *isNull)
* ----------------------------------------------------------------
*/
static Datum
ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext, bool *isNull)
ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
List *clause;
@ -1555,7 +1555,7 @@ ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext, bool *isNull)
* ----------------------------------------------------------------
*/
static Datum
ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone)
{
List *clauses;
@ -1613,7 +1613,7 @@ ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalArray(ArrayExprState * astate, ExprContext *econtext,
ExecEvalArray(ArrayExprState *astate, ExprContext *econtext,
bool *isNull)
{
ArrayExpr *arrayExpr = (ArrayExpr *) astate->xprstate.expr;
@ -1770,7 +1770,7 @@ ExecEvalArray(ArrayExprState * astate, ExprContext *econtext,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalCoalesce(CoalesceExprState * coalesceExpr, ExprContext *econtext,
ExecEvalCoalesce(CoalesceExprState *coalesceExpr, ExprContext *econtext,
bool *isNull)
{
List *arg;
@ -1800,7 +1800,7 @@ ExecEvalCoalesce(CoalesceExprState * coalesceExpr, ExprContext *econtext,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalNullIf(FuncExprState * fcache, ExprContext *econtext,
ExecEvalNullIf(FuncExprState *fcache, ExprContext *econtext,
bool *isNull)
{
Datum result;
@ -1859,7 +1859,7 @@ ExecEvalNullIf(FuncExprState * fcache, ExprContext *econtext,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalNullTest(GenericExprState * nstate,
ExecEvalNullTest(GenericExprState *nstate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -1904,7 +1904,7 @@ ExecEvalNullTest(GenericExprState * nstate,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalBooleanTest(GenericExprState * bstate,
ExecEvalBooleanTest(GenericExprState *bstate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -1990,7 +1990,7 @@ ExecEvalBooleanTest(GenericExprState * bstate,
* datum) otherwise throw an error.
*/
static Datum
ExecEvalCoerceToDomain(CoerceToDomainState * cstate, ExprContext *econtext,
ExecEvalCoerceToDomain(CoerceToDomainState *cstate, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone)
{
CoerceToDomain *ctest = (CoerceToDomain *) cstate->xprstate.expr;
@ -2067,7 +2067,7 @@ ExecEvalCoerceToDomain(CoerceToDomainState * cstate, ExprContext *econtext,
* Return the value stored by CoerceToDomain.
*/
static Datum
ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
ExecEvalCoerceToDomainValue(CoerceToDomainValue *conVal,
ExprContext *econtext, bool *isNull)
{
*isNull = econtext->domainValue_isNull;
@ -2081,7 +2081,7 @@ ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalFieldSelect(GenericExprState * fstate,
ExecEvalFieldSelect(GenericExprState *fstate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -2145,7 +2145,7 @@ ExecEvalFieldSelect(GenericExprState * fstate,
* ----------------------------------------------------------------
*/
Datum
ExecEvalExpr(ExprState * expression,
ExecEvalExpr(ExprState *expression,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -2312,7 +2312,7 @@ ExecEvalExpr(ExprState * expression,
* Same as above, but get into the right allocation context explicitly.
*/
Datum
ExecEvalExprSwitchContext(ExprState * expression,
ExecEvalExprSwitchContext(ExprState *expression,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
@ -2360,7 +2360,7 @@ ExecEvalExprSwitchContext(ExprState * expression,
* This case should usually come through ExecPrepareExpr, not directly here.
*/
ExprState *
ExecInitExpr(Expr *node, PlanState * parent)
ExecInitExpr(Expr *node, PlanState *parent)
{
ExprState *state;
@ -2683,7 +2683,7 @@ ExecInitExpr(Expr *node, PlanState * parent)
* subplan list.
*/
SubPlanState *
ExecInitExprInitPlan(SubPlan *node, PlanState * parent)
ExecInitExprInitPlan(SubPlan *node, PlanState *parent)
{
SubPlanState *sstate = makeNode(SubPlanState);

6
src/backend/executor/execScan.c
View File

@ -12,7 +12,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.26 2003/08/08 14:39:45 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.27 2003/08/08 21:41:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -45,7 +45,7 @@ static bool tlist_matches_tupdesc(List *tlist, Index varno, TupleDesc tupdesc);
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecScan(ScanState * node,
ExecScan(ScanState *node,
ExecScanAccessMtd accessMtd) /* function returning a tuple */
{
EState *estate;
@ -176,7 +176,7 @@ ExecScan(ScanState * node,
* ExecAssignScanType must have been called already.
*/
void
ExecAssignScanProjectionInfo(ScanState * node)
ExecAssignScanProjectionInfo(ScanState *node)
{
Scan *scan = (Scan *) node->ps.plan;

6
src/backend/executor/execTuples.c
View File

@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.70 2003/08/06 17:46:45 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.71 2003/08/08 21:41:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -482,7 +482,7 @@ ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, /* slot to change */
* ----------------
*/
void
ExecInitResultTupleSlot(EState *estate, PlanState * planstate)
ExecInitResultTupleSlot(EState *estate, PlanState *planstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
@ -494,7 +494,7 @@ ExecInitResultTupleSlot(EState *estate, PlanState * planstate)
* ----------------
*/
void
ExecInitScanTupleSlot(EState *estate, ScanState * scanstate)
ExecInitScanTupleSlot(EState *estate, ScanState *scanstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;

24
src/backend/executor/execUtils.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.102 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.103 2003/08/08 21:41:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -385,7 +385,7 @@ MakePerTupleExprContext(EState *estate)
* ----------------
*/
void
ExecAssignExprContext(EState *estate, PlanState * planstate)
ExecAssignExprContext(EState *estate, PlanState *planstate)
{
planstate->ps_ExprContext = CreateExprContext(estate);
}
@ -395,7 +395,7 @@ ExecAssignExprContext(EState *estate, PlanState * planstate)
* ----------------
*/
void
ExecAssignResultType(PlanState * planstate,
ExecAssignResultType(PlanState *planstate,
TupleDesc tupDesc, bool shouldFree)
{
TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
@ -408,7 +408,7 @@ ExecAssignResultType(PlanState * planstate,
* ----------------
*/
void
ExecAssignResultTypeFromOuterPlan(PlanState * planstate)
ExecAssignResultTypeFromOuterPlan(PlanState *planstate)
{
PlanState *outerPlan;
TupleDesc tupDesc;
@ -424,7 +424,7 @@ ExecAssignResultTypeFromOuterPlan(PlanState * planstate)
* ----------------
*/
void
ExecAssignResultTypeFromTL(PlanState * planstate)
ExecAssignResultTypeFromTL(PlanState *planstate)
{
bool hasoid = false;
TupleDesc tupDesc;
@ -479,7 +479,7 @@ ExecAssignResultTypeFromTL(PlanState * planstate)
* ----------------
*/
TupleDesc
ExecGetResultType(PlanState * planstate)
ExecGetResultType(PlanState *planstate)
{
TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
@ -525,7 +525,7 @@ ExecBuildProjectionInfo(List *targetList,
* ----------------
*/
void
ExecAssignProjectionInfo(PlanState * planstate)
ExecAssignProjectionInfo(PlanState *planstate)
{
planstate->ps_ProjInfo =
ExecBuildProjectionInfo(planstate->targetlist,
@ -544,7 +544,7 @@ ExecAssignProjectionInfo(PlanState * planstate)
* ----------------
*/
void
ExecFreeExprContext(PlanState * planstate)
ExecFreeExprContext(PlanState *planstate)
{
ExprContext *econtext;
@ -576,7 +576,7 @@ ExecFreeExprContext(PlanState * planstate)
* ----------------
*/
TupleDesc
ExecGetScanType(ScanState * scanstate)
ExecGetScanType(ScanState *scanstate)
{
TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
@ -588,7 +588,7 @@ ExecGetScanType(ScanState * scanstate)
* ----------------
*/
void
ExecAssignScanType(ScanState * scanstate,
ExecAssignScanType(ScanState *scanstate,
TupleDesc tupDesc, bool shouldFree)
{
TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
@ -601,7 +601,7 @@ ExecAssignScanType(ScanState * scanstate,
* ----------------
*/
void
ExecAssignScanTypeFromOuterPlan(ScanState * scanstate)
ExecAssignScanTypeFromOuterPlan(ScanState *scanstate)
{
PlanState *outerPlan;
TupleDesc tupDesc;
@ -879,7 +879,7 @@ ExecInsertIndexTuples(TupleTableSlot *slot,
* Add changed parameters to a plan node's chgParam set
*/
void
UpdateChangedParamSet(PlanState * node, Bitmapset * newchg)
UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
{
Bitmapset *parmset;

4
src/backend/executor/nodeAgg.c
View File

@ -45,7 +45,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.114 2003/08/04 02:39:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.115 2003/08/08 21:41:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -579,7 +579,7 @@ build_hash_table(AggState *aggstate)
Assert(node->numGroups > 0);
entrysize = sizeof(AggHashEntryData) +
(aggstate->numaggs - 1) * sizeof(AggStatePerGroupData);
(aggstate->numaggs - 1) *sizeof(AggStatePerGroupData);
aggstate->hashtable = BuildTupleHashTable(node->numCols,
node->grpColIdx,

6
src/backend/executor/nodeHashjoin.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.55 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.56 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -22,7 +22,7 @@
#include "utils/memutils.h"
static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState * node,
static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState *node,
HashJoinState *hjstate);
static TupleTableSlot *ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
BufFile *file,
@ -499,7 +499,7 @@ ExecEndHashJoin(HashJoinState *node)
*/
static TupleTableSlot *
ExecHashJoinOuterGetTuple(PlanState * node, HashJoinState *hjstate)
ExecHashJoinOuterGetTuple(PlanState *node, HashJoinState *hjstate)
{
HashJoinTable hashtable = hjstate->hj_HashTable;
int curbatch = hashtable->curbatch;

4
src/backend/executor/nodeMergejoin.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.60 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.61 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -102,7 +102,7 @@ static bool MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext)
*/
static void
MJFormSkipQuals(List *qualList, List **ltQuals, List **gtQuals,
PlanState * parent)
PlanState *parent)
{
List *ltexprs,
*gtexprs,

20
src/backend/executor/nodeSeqscan.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.45 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.46 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -29,8 +29,8 @@
#include "executor/nodeSeqscan.h"
#include "parser/parsetree.h"
static void InitScanRelation(SeqScanState * node, EState *estate);
static TupleTableSlot *SeqNext(SeqScanState * node);
static void InitScanRelation(SeqScanState *node, EState *estate);
static TupleTableSlot *SeqNext(SeqScanState *node);
/* ----------------------------------------------------------------
* Scan Support
@ -43,7 +43,7 @@ static TupleTableSlot *SeqNext(SeqScanState * node);
* ----------------------------------------------------------------
*/
static TupleTableSlot *
SeqNext(SeqScanState * node)
SeqNext(SeqScanState *node)
{
HeapTuple tuple;
HeapScanDesc scandesc;
@ -123,7 +123,7 @@ SeqNext(SeqScanState * node)
*/
TupleTableSlot *
ExecSeqScan(SeqScanState * node)
ExecSeqScan(SeqScanState *node)
{
/*
* use SeqNext as access method
@ -139,7 +139,7 @@ ExecSeqScan(SeqScanState * node)
* ----------------------------------------------------------------
*/
static void
InitScanRelation(SeqScanState * node, EState *estate)
InitScanRelation(SeqScanState *node, EState *estate)
{
Index relid;
List *rangeTable;
@ -252,7 +252,7 @@ ExecCountSlotsSeqScan(SeqScan *node)
* ----------------------------------------------------------------
*/
void
ExecEndSeqScan(SeqScanState * node)
ExecEndSeqScan(SeqScanState *node)
{
Relation relation;
HeapScanDesc scanDesc;
@ -302,7 +302,7 @@ ExecEndSeqScan(SeqScanState * node)
* ----------------------------------------------------------------
*/
void
ExecSeqReScan(SeqScanState * node, ExprContext *exprCtxt)
ExecSeqReScan(SeqScanState *node, ExprContext *exprCtxt)
{
EState *estate;
Index scanrelid;
@ -332,7 +332,7 @@ ExecSeqReScan(SeqScanState * node, ExprContext *exprCtxt)
* ----------------------------------------------------------------
*/
void
ExecSeqMarkPos(SeqScanState * node)
ExecSeqMarkPos(SeqScanState *node)
{
HeapScanDesc scan;
@ -347,7 +347,7 @@ ExecSeqMarkPos(SeqScanState * node)
* ----------------------------------------------------------------
*/
void
ExecSeqRestrPos(SeqScanState * node)
ExecSeqRestrPos(SeqScanState *node)
{
HeapScanDesc scan;

24
src/backend/executor/nodeSubplan.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.53 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.54 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -29,13 +29,13 @@
#include "utils/lsyscache.h"
static Datum ExecHashSubPlan(SubPlanState * node,
static Datum ExecHashSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull);
static Datum ExecScanSubPlan(SubPlanState * node,
static Datum ExecScanSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull);
static void buildSubPlanHash(SubPlanState * node);
static void buildSubPlanHash(SubPlanState *node);
static bool findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot);
static bool tupleAllNulls(HeapTuple tuple);
@ -45,7 +45,7 @@ static bool tupleAllNulls(HeapTuple tuple);
* ----------------------------------------------------------------
*/
Datum
ExecSubPlan(SubPlanState * node,
ExecSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull)
{
@ -64,7 +64,7 @@ ExecSubPlan(SubPlanState * node,
* ExecHashSubPlan: store subselect result in an in-memory hash table
*/
static Datum
ExecHashSubPlan(SubPlanState * node,
ExecHashSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull)
{
@ -194,7 +194,7 @@ ExecHashSubPlan(SubPlanState * node,
* ExecScanSubPlan: default case where we have to rescan subplan each time
*/
static Datum
ExecScanSubPlan(SubPlanState * node,
ExecScanSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull)
{
@ -461,7 +461,7 @@ ExecScanSubPlan(SubPlanState * node,
* buildSubPlanHash: load hash table by scanning subplan output.
*/
static void
buildSubPlanHash(SubPlanState * node)
buildSubPlanHash(SubPlanState *node)
{
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
PlanState *planstate = node->planstate;
@ -663,7 +663,7 @@ tupleAllNulls(HeapTuple tuple)
* ----------------------------------------------------------------
*/
void
ExecInitSubPlan(SubPlanState * node, EState *estate)
ExecInitSubPlan(SubPlanState *node, EState *estate)
{
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
EState *sp_estate;
@ -899,7 +899,7 @@ ExecInitSubPlan(SubPlanState * node, EState *estate)
* ----------------------------------------------------------------
*/
void
ExecSetParamPlan(SubPlanState * node, ExprContext *econtext)
ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
{
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
PlanState *planstate = node->planstate;
@ -1041,7 +1041,7 @@ ExecSetParamPlan(SubPlanState * node, ExprContext *econtext)
* ----------------------------------------------------------------
*/
void
ExecEndSubPlan(SubPlanState * node)
ExecEndSubPlan(SubPlanState *node)
{
if (node->needShutdown)
{
@ -1061,7 +1061,7 @@ ExecEndSubPlan(SubPlanState * node)
* Mark an initplan as needing recalculation
*/
void
ExecReScanSetParamPlan(SubPlanState * node, PlanState * parent)
ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
{
PlanState *planstate = node->planstate;
SubPlan *subplan = (SubPlan *) node->xprstate.expr;

9
src/backend/executor/spi.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.102 2003/08/08 19:18:21 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.103 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -1288,9 +1288,10 @@ _SPI_cursor_operation(Portal portal, bool forward, int count,
* Think not to combine this store with the preceding function call.
* If the portal contains calls to functions that use SPI, then
* SPI_stack is likely to move around while the portal runs. When
* control returns, _SPI_current will point to the correct stack entry...
* but the pointer may be different than it was beforehand. So we must
* be sure to re-fetch the pointer after the function call completes.
* control returns, _SPI_current will point to the correct stack
* entry... but the pointer may be different than it was beforehand.
* So we must be sure to re-fetch the pointer after the function call
* completes.
*/
_SPI_current->processed = nfetched;

2
src/backend/executor/tstoreReceiver.c
View File

@ -9,7 +9,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/tstoreReceiver.c,v 1.9 2003/08/06 17:46:45 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/tstoreReceiver.c,v 1.10 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/

44
src/backend/nodes/bitmapset.c
View File

@ -14,7 +14,7 @@
* Copyright (c) 2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/bitmapset.c,v 1.4 2003/08/04 00:43:18 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/bitmapset.c,v 1.5 2003/08/08 21:41:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -107,7 +107,7 @@ static const uint8 number_of_ones[256] = {
* bms_copy - make a palloc'd copy of a bitmapset
*/
Bitmapset *
bms_copy(const Bitmapset * a)
bms_copy(const Bitmapset *a)
{
Bitmapset *result;
size_t size;
@ -127,7 +127,7 @@ bms_copy(const Bitmapset * a)
* be reported as equal to a palloc'd value containing no members.
*/
bool
bms_equal(const Bitmapset * a, const Bitmapset * b)
bms_equal(const Bitmapset *a, const Bitmapset *b)
{
const Bitmapset *shorter;
const Bitmapset *longer;
@ -197,7 +197,7 @@ bms_make_singleton(int x)
* Same as pfree except for allowing NULL input
*/
void
bms_free(Bitmapset * a)
bms_free(Bitmapset *a)
{
if (a)
pfree(a);
@ -214,7 +214,7 @@ bms_free(Bitmapset * a)
* bms_union - set union
*/
Bitmapset *
bms_union(const Bitmapset * a, const Bitmapset * b)
bms_union(const Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
const Bitmapset *other;
@ -248,7 +248,7 @@ bms_union(const Bitmapset * a, const Bitmapset * b)
* bms_intersect - set intersection
*/
Bitmapset *
bms_intersect(const Bitmapset * a, const Bitmapset * b)
bms_intersect(const Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
const Bitmapset *other;
@ -280,7 +280,7 @@ bms_intersect(const Bitmapset * a, const Bitmapset * b)
* bms_difference - set difference (ie, A without members of B)
*/
Bitmapset *
bms_difference(const Bitmapset * a, const Bitmapset * b)
bms_difference(const Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
int shortlen;
@ -304,7 +304,7 @@ bms_difference(const Bitmapset * a, const Bitmapset * b)
* bms_is_subset - is A a subset of B?
*/
bool
bms_is_subset(const Bitmapset * a, const Bitmapset * b)
bms_is_subset(const Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int longlen;
@ -339,7 +339,7 @@ bms_is_subset(const Bitmapset * a, const Bitmapset * b)
* bms_is_member - is X a member of A?
*/
bool
bms_is_member(int x, const Bitmapset * a)
bms_is_member(int x, const Bitmapset *a)
{
int wordnum,
bitnum;
@ -362,7 +362,7 @@ bms_is_member(int x, const Bitmapset * a)
* bms_overlap - do sets overlap (ie, have a nonempty intersection)?
*/
bool
bms_overlap(const Bitmapset * a, const Bitmapset * b)
bms_overlap(const Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
@ -384,7 +384,7 @@ bms_overlap(const Bitmapset * a, const Bitmapset * b)
* bms_nonempty_difference - do sets have a nonempty difference?
*/
bool
bms_nonempty_difference(const Bitmapset * a, const Bitmapset * b)
bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
@ -416,7 +416,7 @@ bms_nonempty_difference(const Bitmapset * a, const Bitmapset * b)
* Raises error if |a| is not 1.
*/
int
bms_singleton_member(const Bitmapset * a)
bms_singleton_member(const Bitmapset *a)
{
int result = -1;
int nwords;
@ -451,7 +451,7 @@ bms_singleton_member(const Bitmapset * a)
* bms_num_members - count members of set
*/
int
bms_num_members(const Bitmapset * a)
bms_num_members(const Bitmapset *a)
{
int result = 0;
int nwords;
@ -480,7 +480,7 @@ bms_num_members(const Bitmapset * a)
* This is faster than making an exact count with bms_num_members().
*/
BMS_Membership
bms_membership(const Bitmapset * a)
bms_membership(const Bitmapset *a)
{
BMS_Membership result = BMS_EMPTY_SET;
int nwords;
@ -509,7 +509,7 @@ bms_membership(const Bitmapset * a)
* This is even faster than bms_membership().
*/
bool
bms_is_empty(const Bitmapset * a)
bms_is_empty(const Bitmapset *a)
{
int nwords;
int wordnum;
@ -544,7 +544,7 @@ bms_is_empty(const Bitmapset * a)
* Input set is modified or recycled!
*/
Bitmapset *
bms_add_member(Bitmapset * a, int x)
bms_add_member(Bitmapset *a, int x)
{
int wordnum,
bitnum;
@ -582,7 +582,7 @@ bms_add_member(Bitmapset * a, int x)
* Input set is modified in-place!
*/
Bitmapset *
bms_del_member(Bitmapset * a, int x)
bms_del_member(Bitmapset *a, int x)
{
int wordnum,
bitnum;
@ -602,7 +602,7 @@ bms_del_member(Bitmapset * a, int x)
* bms_add_members - like bms_union, but left input is recycled
*/
Bitmapset *
bms_add_members(Bitmapset * a, const Bitmapset * b)
bms_add_members(Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
const Bitmapset *other;
@ -638,7 +638,7 @@ bms_add_members(Bitmapset * a, const Bitmapset * b)
* bms_int_members - like bms_intersect, but left input is recycled
*/
Bitmapset *
bms_int_members(Bitmapset * a, const Bitmapset * b)
bms_int_members(Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
@ -664,7 +664,7 @@ bms_int_members(Bitmapset * a, const Bitmapset * b)
* bms_del_members - like bms_difference, but left input is recycled
*/
Bitmapset *
bms_del_members(Bitmapset * a, const Bitmapset * b)
bms_del_members(Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
@ -685,7 +685,7 @@ bms_del_members(Bitmapset * a, const Bitmapset * b)
* bms_join - like bms_union, but *both* inputs are recycled
*/
Bitmapset *
bms_join(Bitmapset * a, Bitmapset * b)
bms_join(Bitmapset *a, Bitmapset *b)
{
Bitmapset *result;
Bitmapset *other;
@ -732,7 +732,7 @@ bms_join(Bitmapset * a, Bitmapset * b)
*----------
*/
int
bms_first_member(Bitmapset * a)
bms_first_member(Bitmapset *a)
{
int nwords;
int wordnum;

34
src/backend/nodes/copyfuncs.c
View File

@ -15,7 +15,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.262 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.263 2003/08/08 21:41:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -755,7 +755,7 @@ _copyArrayRef(ArrayRef *from)
* _copyFuncExpr
*/
static FuncExpr *
_copyFuncExpr(FuncExpr * from)
_copyFuncExpr(FuncExpr *from)
{
FuncExpr *newnode = makeNode(FuncExpr);
@ -772,7 +772,7 @@ _copyFuncExpr(FuncExpr * from)
* _copyOpExpr
*/
static OpExpr *
_copyOpExpr(OpExpr * from)
_copyOpExpr(OpExpr *from)
{
OpExpr *newnode = makeNode(OpExpr);
@ -789,7 +789,7 @@ _copyOpExpr(OpExpr * from)
* _copyDistinctExpr (same as OpExpr)
*/
static DistinctExpr *
_copyDistinctExpr(DistinctExpr * from)
_copyDistinctExpr(DistinctExpr *from)
{
DistinctExpr *newnode = makeNode(DistinctExpr);
@ -806,7 +806,7 @@ _copyDistinctExpr(DistinctExpr * from)
* _copyScalarArrayOpExpr
*/
static ScalarArrayOpExpr *
_copyScalarArrayOpExpr(ScalarArrayOpExpr * from)
_copyScalarArrayOpExpr(ScalarArrayOpExpr *from)
{
ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
@ -822,7 +822,7 @@ _copyScalarArrayOpExpr(ScalarArrayOpExpr * from)
* _copyBoolExpr
*/
static BoolExpr *
_copyBoolExpr(BoolExpr * from)
_copyBoolExpr(BoolExpr *from)
{
BoolExpr *newnode = makeNode(BoolExpr);
@ -940,7 +940,7 @@ _copyCaseWhen(CaseWhen *from)
* _copyArrayExpr
*/
static ArrayExpr *
_copyArrayExpr(ArrayExpr * from)
_copyArrayExpr(ArrayExpr *from)
{
ArrayExpr *newnode = makeNode(ArrayExpr);
@ -956,7 +956,7 @@ _copyArrayExpr(ArrayExpr * from)
* _copyCoalesceExpr
*/
static CoalesceExpr *
_copyCoalesceExpr(CoalesceExpr * from)
_copyCoalesceExpr(CoalesceExpr *from)
{
CoalesceExpr *newnode = makeNode(CoalesceExpr);
@ -970,7 +970,7 @@ _copyCoalesceExpr(CoalesceExpr * from)
* _copyNullIfExpr (same as OpExpr)
*/
static NullIfExpr *
_copyNullIfExpr(NullIfExpr * from)
_copyNullIfExpr(NullIfExpr *from)
{
NullIfExpr *newnode = makeNode(NullIfExpr);
@ -1015,7 +1015,7 @@ _copyBooleanTest(BooleanTest *from)
* _copyCoerceToDomain
*/
static CoerceToDomain *
_copyCoerceToDomain(CoerceToDomain * from)
_copyCoerceToDomain(CoerceToDomain *from)
{
CoerceToDomain *newnode = makeNode(CoerceToDomain);
@ -1031,7 +1031,7 @@ _copyCoerceToDomain(CoerceToDomain * from)
* _copyCoerceToDomainValue
*/
static CoerceToDomainValue *
_copyCoerceToDomainValue(CoerceToDomainValue * from)
_copyCoerceToDomainValue(CoerceToDomainValue *from)
{
CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
@ -1045,7 +1045,7 @@ _copyCoerceToDomainValue(CoerceToDomainValue * from)
* _copySetToDefault
*/
static SetToDefault *
_copySetToDefault(SetToDefault * from)
_copySetToDefault(SetToDefault *from)
{
SetToDefault *newnode = makeNode(SetToDefault);
@ -1191,7 +1191,7 @@ _copyJoinInfo(JoinInfo *from)
* _copyInClauseInfo
*/
static InClauseInfo *
_copyInClauseInfo(InClauseInfo * from)
_copyInClauseInfo(InClauseInfo *from)
{
InClauseInfo *newnode = makeNode(InClauseInfo);
@ -1633,7 +1633,7 @@ _copyAlterTableStmt(AlterTableStmt *from)
}
static AlterDomainStmt *
_copyAlterDomainStmt(AlterDomainStmt * from)
_copyAlterDomainStmt(AlterDomainStmt *from)
{
AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
@ -1685,7 +1685,7 @@ _copyFuncWithArgs(FuncWithArgs *from)
}
static DeclareCursorStmt *
_copyDeclareCursorStmt(DeclareCursorStmt * from)
_copyDeclareCursorStmt(DeclareCursorStmt *from)
{
DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
@ -1747,7 +1747,7 @@ _copyCreateStmt(CreateStmt *from)
}
static InhRelation *
_copyInhRelation(InhRelation * from)
_copyInhRelation(InhRelation *from)
{
InhRelation *newnode = makeNode(InhRelation);
@ -2118,7 +2118,7 @@ _copyCreateSeqStmt(CreateSeqStmt *from)
}
static AlterSeqStmt *
_copyAlterSeqStmt(AlterSeqStmt * from)
_copyAlterSeqStmt(AlterSeqStmt *from)
{
AlterSeqStmt *newnode = makeNode(AlterSeqStmt);

34
src/backend/nodes/equalfuncs.c
View File

@ -18,7 +18,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.206 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.207 2003/08/08 21:41:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -224,7 +224,7 @@ _equalArrayRef(ArrayRef *a, ArrayRef *b)
}
static bool
_equalFuncExpr(FuncExpr * a, FuncExpr * b)
_equalFuncExpr(FuncExpr *a, FuncExpr *b)
{
COMPARE_SCALAR_FIELD(funcid);
COMPARE_SCALAR_FIELD(funcresulttype);
@ -245,7 +245,7 @@ _equalFuncExpr(FuncExpr * a, FuncExpr * b)
}
static bool
_equalOpExpr(OpExpr * a, OpExpr * b)
_equalOpExpr(OpExpr *a, OpExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
@ -268,7 +268,7 @@ _equalOpExpr(OpExpr * a, OpExpr * b)
}
static bool
_equalDistinctExpr(DistinctExpr * a, DistinctExpr * b)
_equalDistinctExpr(DistinctExpr *a, DistinctExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
@ -291,7 +291,7 @@ _equalDistinctExpr(DistinctExpr * a, DistinctExpr * b)
}
static bool
_equalScalarArrayOpExpr(ScalarArrayOpExpr * a, ScalarArrayOpExpr * b)
_equalScalarArrayOpExpr(ScalarArrayOpExpr *a, ScalarArrayOpExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
@ -313,7 +313,7 @@ _equalScalarArrayOpExpr(ScalarArrayOpExpr * a, ScalarArrayOpExpr * b)
}
static bool
_equalBoolExpr(BoolExpr * a, BoolExpr * b)
_equalBoolExpr(BoolExpr *a, BoolExpr *b)
{
COMPARE_SCALAR_FIELD(boolop);
COMPARE_NODE_FIELD(args);
@ -404,7 +404,7 @@ _equalCaseWhen(CaseWhen *a, CaseWhen *b)
}
static bool
_equalArrayExpr(ArrayExpr * a, ArrayExpr * b)
_equalArrayExpr(ArrayExpr *a, ArrayExpr *b)
{
COMPARE_SCALAR_FIELD(array_typeid);
COMPARE_SCALAR_FIELD(element_typeid);
@ -415,7 +415,7 @@ _equalArrayExpr(ArrayExpr * a, ArrayExpr * b)
}
static bool
_equalCoalesceExpr(CoalesceExpr * a, CoalesceExpr * b)
_equalCoalesceExpr(CoalesceExpr *a, CoalesceExpr *b)
{
COMPARE_SCALAR_FIELD(coalescetype);
COMPARE_NODE_FIELD(args);
@ -424,7 +424,7 @@ _equalCoalesceExpr(CoalesceExpr * a, CoalesceExpr * b)
}
static bool
_equalNullIfExpr(NullIfExpr * a, NullIfExpr * b)
_equalNullIfExpr(NullIfExpr *a, NullIfExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
@ -465,7 +465,7 @@ _equalBooleanTest(BooleanTest *a, BooleanTest *b)
}
static bool
_equalCoerceToDomain(CoerceToDomain * a, CoerceToDomain * b)
_equalCoerceToDomain(CoerceToDomain *a, CoerceToDomain *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(resulttype);
@ -484,7 +484,7 @@ _equalCoerceToDomain(CoerceToDomain * a, CoerceToDomain * b)
}
static bool
_equalCoerceToDomainValue(CoerceToDomainValue * a, CoerceToDomainValue * b)
_equalCoerceToDomainValue(CoerceToDomainValue *a, CoerceToDomainValue *b)
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
@ -493,7 +493,7 @@ _equalCoerceToDomainValue(CoerceToDomainValue * a, CoerceToDomainValue * b)
}
static bool
_equalSetToDefault(SetToDefault * a, SetToDefault * b)
_equalSetToDefault(SetToDefault *a, SetToDefault *b)
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
@ -587,7 +587,7 @@ _equalJoinInfo(JoinInfo *a, JoinInfo *b)
}
static bool
_equalInClauseInfo(InClauseInfo * a, InClauseInfo * b)
_equalInClauseInfo(InClauseInfo *a, InClauseInfo *b)
{
COMPARE_BITMAPSET_FIELD(lefthand);
COMPARE_BITMAPSET_FIELD(righthand);
@ -715,7 +715,7 @@ _equalAlterTableStmt(AlterTableStmt *a, AlterTableStmt *b)
}
static bool
_equalAlterDomainStmt(AlterDomainStmt * a, AlterDomainStmt * b)
_equalAlterDomainStmt(AlterDomainStmt *a, AlterDomainStmt *b)
{
COMPARE_SCALAR_FIELD(subtype);
COMPARE_NODE_FIELD(typename);
@ -759,7 +759,7 @@ _equalFuncWithArgs(FuncWithArgs *a, FuncWithArgs *b)
}
static bool
_equalDeclareCursorStmt(DeclareCursorStmt * a, DeclareCursorStmt * b)
_equalDeclareCursorStmt(DeclareCursorStmt *a, DeclareCursorStmt *b)
{
COMPARE_STRING_FIELD(portalname);
COMPARE_SCALAR_FIELD(options);
@ -811,7 +811,7 @@ _equalCreateStmt(CreateStmt *a, CreateStmt *b)
}
static bool
_equalInhRelation(InhRelation * a, InhRelation * b)
_equalInhRelation(InhRelation *a, InhRelation *b)
{
COMPARE_NODE_FIELD(relation);
COMPARE_SCALAR_FIELD(including_defaults);
@ -1122,7 +1122,7 @@ _equalCreateSeqStmt(CreateSeqStmt *a, CreateSeqStmt *b)
}
static bool
_equalAlterSeqStmt(AlterSeqStmt * a, AlterSeqStmt * b)
_equalAlterSeqStmt(AlterSeqStmt *a, AlterSeqStmt *b)
{
COMPARE_NODE_FIELD(sequence);
COMPARE_NODE_FIELD(options);

12
src/backend/nodes/list.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.53 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.54 2003/08/08 21:41:44 momjian Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
@ -202,7 +202,7 @@ nconc(List *l1, List *l2)
* since we avoid having to chase down the list again each time.
*/
void
FastAppend(FastList * fl, void *datum)
FastAppend(FastList *fl, void *datum)
{
List *cell = makeList1(datum);
@ -223,7 +223,7 @@ FastAppend(FastList * fl, void *datum)
* FastAppendi - same for integers
*/
void
FastAppendi(FastList * fl, int datum)
FastAppendi(FastList *fl, int datum)
{
List *cell = makeListi1(datum);
@ -244,7 +244,7 @@ FastAppendi(FastList * fl, int datum)
* FastAppendo - same for Oids
*/
void
FastAppendo(FastList * fl, Oid datum)
FastAppendo(FastList *fl, Oid datum)
{
List *cell = makeListo1(datum);
@ -267,7 +267,7 @@ FastAppendo(FastList * fl, Oid datum)
* Note that the cells of the second argument are absorbed into the FastList.
*/
void
FastConc(FastList * fl, List *cells)
FastConc(FastList *fl, List *cells)
{
if (cells == NIL)
return; /* nothing to do */
@ -290,7 +290,7 @@ FastConc(FastList * fl, List *cells)
* Note that the cells of the second argument are absorbed into the first.
*/
void
FastConcFast(FastList * fl, FastList * fl2)
FastConcFast(FastList *fl, FastList *fl2)
{
if (fl2->head == NIL)
return; /* nothing to do */

36
src/backend/nodes/outfuncs.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.216 2003/08/04 02:39:59 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.217 2003/08/08 21:41:44 momjian Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
@ -184,7 +184,7 @@ _outOidList(StringInfo str, List *list)
* an integer List would be.
*/
static void
_outBitmapset(StringInfo str, Bitmapset * bms)
_outBitmapset(StringInfo str, Bitmapset *bms)
{
Bitmapset *tmpset;
int x;
@ -631,7 +631,7 @@ _outArrayRef(StringInfo str, ArrayRef *node)
}
static void
_outFuncExpr(StringInfo str, FuncExpr * node)
_outFuncExpr(StringInfo str, FuncExpr *node)
{
WRITE_NODE_TYPE("FUNCEXPR");
@ -643,7 +643,7 @@ _outFuncExpr(StringInfo str, FuncExpr * node)
}
static void
_outOpExpr(StringInfo str, OpExpr * node)
_outOpExpr(StringInfo str, OpExpr *node)
{
WRITE_NODE_TYPE("OPEXPR");
@ -655,7 +655,7 @@ _outOpExpr(StringInfo str, OpExpr * node)
}
static void
_outDistinctExpr(StringInfo str, DistinctExpr * node)
_outDistinctExpr(StringInfo str, DistinctExpr *node)
{
WRITE_NODE_TYPE("DISTINCTEXPR");
@ -667,7 +667,7 @@ _outDistinctExpr(StringInfo str, DistinctExpr * node)
}
static void
_outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr * node)
_outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr *node)
{
WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
@ -678,7 +678,7 @@ _outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr * node)
}
static void
_outBoolExpr(StringInfo str, BoolExpr * node)
_outBoolExpr(StringInfo str, BoolExpr *node)
{
char *opstr = NULL;
@ -778,7 +778,7 @@ _outCaseWhen(StringInfo str, CaseWhen *node)
}
static void
_outArrayExpr(StringInfo str, ArrayExpr * node)
_outArrayExpr(StringInfo str, ArrayExpr *node)
{
WRITE_NODE_TYPE("ARRAY");
@ -789,7 +789,7 @@ _outArrayExpr(StringInfo str, ArrayExpr * node)
}
static void
_outCoalesceExpr(StringInfo str, CoalesceExpr * node)
_outCoalesceExpr(StringInfo str, CoalesceExpr *node)
{
WRITE_NODE_TYPE("COALESCE");
@ -798,7 +798,7 @@ _outCoalesceExpr(StringInfo str, CoalesceExpr * node)
}
static void
_outNullIfExpr(StringInfo str, NullIfExpr * node)
_outNullIfExpr(StringInfo str, NullIfExpr *node)
{
WRITE_NODE_TYPE("NULLIFEXPR");
@ -828,7 +828,7 @@ _outBooleanTest(StringInfo str, BooleanTest *node)
}
static void
_outCoerceToDomain(StringInfo str, CoerceToDomain * node)
_outCoerceToDomain(StringInfo str, CoerceToDomain *node)
{
WRITE_NODE_TYPE("COERCETODOMAIN");
@ -839,7 +839,7 @@ _outCoerceToDomain(StringInfo str, CoerceToDomain * node)
}
static void
_outCoerceToDomainValue(StringInfo str, CoerceToDomainValue * node)
_outCoerceToDomainValue(StringInfo str, CoerceToDomainValue *node)
{
WRITE_NODE_TYPE("COERCETODOMAINVALUE");
@ -848,7 +848,7 @@ _outCoerceToDomainValue(StringInfo str, CoerceToDomainValue * node)
}
static void
_outSetToDefault(StringInfo str, SetToDefault * node)
_outSetToDefault(StringInfo str, SetToDefault *node)
{
WRITE_NODE_TYPE("SETTODEFAULT");
@ -977,7 +977,7 @@ _outAppendPath(StringInfo str, AppendPath *node)
}
static void
_outResultPath(StringInfo str, ResultPath * node)
_outResultPath(StringInfo str, ResultPath *node)
{
WRITE_NODE_TYPE("RESULTPATH");
@ -988,7 +988,7 @@ _outResultPath(StringInfo str, ResultPath * node)
}
static void
_outMaterialPath(StringInfo str, MaterialPath * node)
_outMaterialPath(StringInfo str, MaterialPath *node)
{
WRITE_NODE_TYPE("MATERIALPATH");
@ -998,7 +998,7 @@ _outMaterialPath(StringInfo str, MaterialPath * node)
}
static void
_outUniquePath(StringInfo str, UniquePath * node)
_outUniquePath(StringInfo str, UniquePath *node)
{
WRITE_NODE_TYPE("UNIQUEPATH");
@ -1077,7 +1077,7 @@ _outJoinInfo(StringInfo str, JoinInfo *node)
}
static void
_outInClauseInfo(StringInfo str, InClauseInfo * node)
_outInClauseInfo(StringInfo str, InClauseInfo *node)
{
WRITE_NODE_TYPE("INCLAUSEINFO");
@ -1130,7 +1130,7 @@ _outNotifyStmt(StringInfo str, NotifyStmt *node)
}
static void
_outDeclareCursorStmt(StringInfo str, DeclareCursorStmt * node)
_outDeclareCursorStmt(StringInfo str, DeclareCursorStmt *node)
{
WRITE_NODE_TYPE("DECLARECURSOR");

8
src/backend/optimizer/path/costsize.c
View File

@ -49,7 +49,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.113 2003/08/04 02:40:00 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.114 2003/08/08 21:41:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -103,7 +103,7 @@ bool enable_hashjoin = true;
static Selectivity estimate_hash_bucketsize(Query *root, Var *var,
int nbuckets);
static bool cost_qual_eval_walker(Node *node, QualCost * total);
static bool cost_qual_eval_walker(Node *node, QualCost *total);
static Selectivity approx_selectivity(Query *root, List *quals,
JoinType jointype);
static void set_rel_width(Query *root, RelOptInfo *rel);
@ -1449,7 +1449,7 @@ estimate_hash_bucketsize(Query *root, Var *var, int nbuckets)
* and a per-evaluation component.
*/
void
cost_qual_eval(QualCost * cost, List *quals)
cost_qual_eval(QualCost *cost, List *quals)
{
List *l;
@ -1491,7 +1491,7 @@ cost_qual_eval(QualCost * cost, List *quals)
}
static bool
cost_qual_eval_walker(Node *node, QualCost * total)
cost_qual_eval_walker(Node *node, QualCost *total)
{
if (node == NULL)
return false;

6
src/backend/optimizer/path/tidpath.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/tidpath.c,v 1.16 2003/08/04 02:40:00 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/tidpath.c,v 1.17 2003/08/08 21:41:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -27,7 +27,7 @@
static List *TidqualFromRestrictinfo(Relids relids, List *restrictinfo);
static bool isEvaluable(int varno, Node *node);
static Node *TidequalClause(int varno, OpExpr * node);
static Node *TidequalClause(int varno, OpExpr *node);
static List *TidqualFromExpr(int varno, Expr *expr);
static bool
@ -66,7 +66,7 @@ isEvaluable(int varno, Node *node)
* or the left node if the opclause is ....=CTID
*/
static Node *
TidequalClause(int varno, OpExpr * node)
TidequalClause(int varno, OpExpr *node)
{
Node *rnode = NULL,
*arg1,

37
src/backend/optimizer/plan/createplan.c
View File

@ -10,7 +10,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.152 2003/08/07 19:20:22 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.153 2003/08/08 21:41:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -40,9 +40,9 @@ static bool use_physical_tlist(RelOptInfo *rel);
static void disuse_physical_tlist(Plan *plan, Path *path);
static Join *create_join_plan(Query *root, JoinPath *best_path);
static Append *create_append_plan(Query *root, AppendPath *best_path);
static Result *create_result_plan(Query *root, ResultPath * best_path);
static Material *create_material_plan(Query *root, MaterialPath * best_path);
static Plan *create_unique_plan(Query *root, UniquePath * best_path);
static Result *create_result_plan(Query *root, ResultPath *best_path);
static Material *create_material_plan(Query *root, MaterialPath *best_path);
static Plan *create_unique_plan(Query *root, UniquePath *best_path);
static SeqScan *create_seqscan_plan(Path *best_path, List *tlist,
List *scan_clauses);
static IndexScan *create_indexscan_plan(Query *root, IndexPath *best_path,
@ -443,7 +443,7 @@ create_append_plan(Query *root, AppendPath *best_path)
* Returns a Plan node.
*/
static Result *
create_result_plan(Query *root, ResultPath * best_path)
create_result_plan(Query *root, ResultPath *best_path)
{
Result *plan;
List *tlist;
@ -475,7 +475,7 @@ create_result_plan(Query *root, ResultPath * best_path)
* Returns a Plan node.
*/
static Material *
create_material_plan(Query *root, MaterialPath * best_path)
create_material_plan(Query *root, MaterialPath *best_path)
{
Material *plan;
Plan *subplan;
@ -500,7 +500,7 @@ create_material_plan(Query *root, MaterialPath * best_path)
* Returns a Plan node.
*/
static Plan *
create_unique_plan(Query *root, UniquePath * best_path)
create_unique_plan(Query *root, UniquePath *best_path)
{
Plan *plan;
Plan *subplan;
@ -522,17 +522,18 @@ create_unique_plan(Query *root, UniquePath * best_path)
* to unique-ify may be expressions in these variables. We have to
* add any such expressions to the subplan's tlist. We then build
* control information showing which subplan output columns are to be
* examined by the grouping step. (Since we do not remove any existing
* subplan outputs, not all the output columns may be used for grouping.)
* examined by the grouping step. (Since we do not remove any
* existing subplan outputs, not all the output columns may be used
* for grouping.)
*
* Note: the reason we don't remove any subplan outputs is that there
* are scenarios where a Var is needed at higher levels even though it
* is not one of the nominal outputs of an IN clause. Consider
* WHERE x IN (SELECT y FROM t1,t2 WHERE y = z)
* Implied equality deduction will generate an "x = z" clause, which may
* get used instead of "x = y" in the upper join step. Therefore the
* sub-select had better deliver both y and z in its targetlist. It is
* sufficient to unique-ify on y, however.
* Note: the reason we don't remove any subplan outputs is that there are
* scenarios where a Var is needed at higher levels even though it is
* not one of the nominal outputs of an IN clause. Consider WHERE x
* IN (SELECT y FROM t1,t2 WHERE y = z) Implied equality deduction
* will generate an "x = z" clause, which may get used instead of "x =
* y" in the upper join step. Therefore the sub-select had better
* deliver both y and z in its targetlist. It is sufficient to
* unique-ify on y, however.
*
* To find the correct list of values to unique-ify, we look in the
* information saved for IN expressions. If this code is ever used in
@ -1208,7 +1209,7 @@ fix_indxqual_sublist(List *indexqual,
Relids leftvarnos;
Oid opclass;
if (!IsA(clause, OpExpr) || length(clause->args) != 2)
if (!IsA(clause, OpExpr) ||length(clause->args) != 2)
elog(ERROR, "indexqual clause is not binary opclause");
/*

8
src/backend/optimizer/plan/setrefs.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.96 2003/08/04 02:40:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.97 2003/08/08 21:41:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -60,7 +60,7 @@ static Node *replace_vars_with_subplan_refs(Node *node,
static Node *replace_vars_with_subplan_refs_mutator(Node *node,
replace_vars_with_subplan_refs_context *context);
static bool fix_opfuncids_walker(Node *node, void *context);
static void set_sa_opfuncid(ScalarArrayOpExpr * opexpr);
static void set_sa_opfuncid(ScalarArrayOpExpr *opexpr);
/*****************************************************************************
@ -759,7 +759,7 @@ fix_opfuncids_walker(Node *node, void *context)
* DistinctExpr and NullIfExpr nodes.
*/
void
set_opfuncid(OpExpr * opexpr)
set_opfuncid(OpExpr *opexpr)
{
if (opexpr->opfuncid == InvalidOid)
opexpr->opfuncid = get_opcode(opexpr->opno);
@ -770,7 +770,7 @@ set_opfuncid(OpExpr * opexpr)
* As above, for ScalarArrayOpExpr nodes.
*/
static void
set_sa_opfuncid(ScalarArrayOpExpr * opexpr)
set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
{
if (opexpr->opfuncid == InvalidOid)
opexpr->opfuncid = get_opcode(opexpr->opno);

12
src/backend/optimizer/plan/subselect.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.81 2003/08/04 02:40:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.82 2003/08/08 21:41:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -88,9 +88,9 @@ static bool subplan_is_hashable(SubLink *slink, SubPlan *node);
static Node *replace_correlation_vars_mutator(Node *node, void *context);
static Node *process_sublinks_mutator(Node *node, bool *isTopQual);
static Bitmapset *finalize_plan(Plan *plan, List *rtable,
Bitmapset * outer_params,
Bitmapset * valid_params);
static bool finalize_primnode(Node *node, finalize_primnode_context * context);
Bitmapset *outer_params,
Bitmapset *valid_params);
static bool finalize_primnode(Node *node, finalize_primnode_context *context);
/*
@ -909,7 +909,7 @@ SS_finalize_plan(Plan *plan, List *rtable)
*/
static Bitmapset *
finalize_plan(Plan *plan, List *rtable,
Bitmapset * outer_params, Bitmapset * valid_params)
Bitmapset *outer_params, Bitmapset *valid_params)
{
finalize_primnode_context context;
List *lst;
@ -1073,7 +1073,7 @@ finalize_plan(Plan *plan, List *rtable,
* expression tree to the result set.
*/
static bool
finalize_primnode(Node *node, finalize_primnode_context * context)
finalize_primnode(Node *node, finalize_primnode_context *context)
{
if (node == NULL)
return false;

6
src/backend/optimizer/prep/prepjointree.c
View File

@ -16,7 +16,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.10 2003/08/04 02:40:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.11 2003/08/08 21:41:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -48,7 +48,7 @@ static bool has_nullable_targetlist(Query *subquery);
static void resolvenew_in_jointree(Node *jtnode, int varno, List *subtlist);
static reduce_outer_joins_state *reduce_outer_joins_pass1(Node *jtnode);
static void reduce_outer_joins_pass2(Node *jtnode,
reduce_outer_joins_state * state,
reduce_outer_joins_state *state,
Query *parse,
Relids nonnullable_rels);
static Relids find_nonnullable_rels(Node *node, bool top_level);
@ -609,7 +609,7 @@ reduce_outer_joins_pass1(Node *jtnode)
*/
static void
reduce_outer_joins_pass2(Node *jtnode,
reduce_outer_joins_state * state,
reduce_outer_joins_state *state,
Query *parse,
Relids nonnullable_rels)
{

18
src/backend/optimizer/prep/prepqual.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.37 2003/08/04 02:40:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.38 2003/08/08 21:41:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -21,12 +21,12 @@
#include "utils/lsyscache.h"
static Expr *flatten_andors(Expr *qual);
static void flatten_andors_and_walker(FastList * out_list, List *andlist);
static void flatten_andors_or_walker(FastList * out_list, List *orlist);
static void flatten_andors_and_walker(FastList *out_list, List *andlist);
static void flatten_andors_or_walker(FastList *out_list, List *orlist);
static List *pull_ands(List *andlist);
static void pull_ands_walker(FastList * out_list, List *andlist);
static void pull_ands_walker(FastList *out_list, List *andlist);
static List *pull_ors(List *orlist);
static void pull_ors_walker(FastList * out_list, List *orlist);
static void pull_ors_walker(FastList *out_list, List *orlist);
static Expr *find_nots(Expr *qual);
static Expr *push_nots(Expr *qual);
static Expr *find_ors(Expr *qual);
@ -328,7 +328,7 @@ flatten_andors(Expr *qual)
}
static void
flatten_andors_and_walker(FastList * out_list, List *andlist)
flatten_andors_and_walker(FastList *out_list, List *andlist)
{
List *arg;
@ -344,7 +344,7 @@ flatten_andors_and_walker(FastList * out_list, List *andlist)
}
static void
flatten_andors_or_walker(FastList * out_list, List *orlist)
flatten_andors_or_walker(FastList *out_list, List *orlist)
{
List *arg;
@ -377,7 +377,7 @@ pull_ands(List *andlist)
}
static void
pull_ands_walker(FastList * out_list, List *andlist)
pull_ands_walker(FastList *out_list, List *andlist)
{
List *arg;
@ -410,7 +410,7 @@ pull_ors(List *orlist)
}
static void
pull_ors_walker(FastList * out_list, List *orlist)
pull_ors_walker(FastList *out_list, List *orlist)
{
List *arg;

8
src/backend/optimizer/util/clauses.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.151 2003/08/04 02:40:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.152 2003/08/08 21:41:55 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@ -70,7 +70,7 @@ static Expr *inline_function(Oid funcid, Oid result_type, List *args,
static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
int *usecounts);
static Node *substitute_actual_parameters_mutator(Node *node,
substitute_actual_parameters_context * context);
substitute_actual_parameters_context *context);
static void sql_inline_error_callback(void *arg);
static Expr *evaluate_expr(Expr *expr, Oid result_type);
@ -981,7 +981,7 @@ NumRelids(Node *clause)
* XXX the clause is destructively modified!
*/
void
CommuteClause(OpExpr * clause)
CommuteClause(OpExpr *clause)
{
Oid opoid;
Node *temp;
@ -2002,7 +2002,7 @@ substitute_actual_parameters(Node *expr, int nargs, List *args,
static Node *
substitute_actual_parameters_mutator(Node *node,
substitute_actual_parameters_context * context)
substitute_actual_parameters_context *context)
{
if (node == NULL)
return NULL;

6
src/backend/optimizer/util/var.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.53 2003/08/04 02:40:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.54 2003/08/08 21:41:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -61,7 +61,7 @@ static bool contain_var_clause_walker(Node *node, void *context);
static bool contain_vars_of_level_walker(Node *node, int *sublevels_up);
static bool contain_vars_above_level_walker(Node *node, int *sublevels_up);
static bool find_minimum_var_level_walker(Node *node,
find_minimum_var_level_context * context);
find_minimum_var_level_context *context);
static bool pull_var_clause_walker(Node *node,
pull_var_clause_context *context);
static Node *flatten_join_alias_vars_mutator(Node *node,
@ -364,7 +364,7 @@ find_minimum_var_level(Node *node)
static bool
find_minimum_var_level_walker(Node *node,
find_minimum_var_level_context * context)
find_minimum_var_level_context *context)
{
if (node == NULL)
return false;

19
src/backend/parser/analyze.c
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.285 2003/08/04 02:40:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.286 2003/08/08 21:41:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -106,7 +106,7 @@ static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt);
static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt);
static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
static Query *transformDeclareCursorStmt(ParseState *pstate,
DeclareCursorStmt * stmt);
DeclareCursorStmt *stmt);
static Query *transformPrepareStmt(ParseState *pstate, PrepareStmt *stmt);
static Query *transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt);
static Query *transformCreateStmt(ParseState *pstate, CreateStmt *stmt,
@ -120,7 +120,7 @@ static void transformTableConstraint(ParseState *pstate,
CreateStmtContext *cxt,
Constraint *constraint);
static void transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
InhRelation * inhrelation);
InhRelation *inhrelation);
static void transformIndexConstraints(ParseState *pstate,
CreateStmtContext *cxt);
static void transformFKConstraints(ParseState *pstate,
@ -135,7 +135,7 @@ static bool relationHasPrimaryKey(Oid relationOid);
static void release_pstate_resources(ParseState *pstate);
static FromExpr *makeFromExpr(List *fromlist, Node *quals);
static bool check_parameter_resolution_walker(Node *node,
check_parameter_resolution_context * context);
check_parameter_resolution_context *context);
/*
@ -1171,7 +1171,7 @@ transformTableConstraint(ParseState *pstate, CreateStmtContext *cxt,
*/
static void
transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
InhRelation * inhRelation)
InhRelation *inhRelation)
{
AttrNumber parent_attno;
@ -1907,9 +1907,8 @@ transformRuleStmt(ParseState *pstate, RuleStmt *stmt,
{
/*
* If sub_qry is a setop, manipulating its jointree will
* do no good at all, because the jointree is dummy.
* (This should be a can't-happen case because of prior
* tests.)
* do no good at all, because the jointree is dummy. (This
* should be a can't-happen case because of prior tests.)
*/
if (sub_qry->setOperations != NULL)
ereport(ERROR,
@ -2643,7 +2642,7 @@ transformAlterTableStmt(ParseState *pstate, AlterTableStmt *stmt,
}
static Query *
transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt * stmt)
transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
{
Query *result = makeNode(Query);
List *extras_before = NIL,
@ -3200,7 +3199,7 @@ analyzeCreateSchemaStmt(CreateSchemaStmt *stmt)
*/
static bool
check_parameter_resolution_walker(Node *node,
check_parameter_resolution_context * context)
check_parameter_resolution_context *context)
{
if (node == NULL)
return false;

4
src/backend/regex/regc_color.c
View File

@ -28,7 +28,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*
* Note that there are some incestuous relationships between this code and
@ -421,7 +421,7 @@ subrange(struct vars * v,
/* first, align "from" on a tree-block boundary */
uf = (uchr) from;
i = (int) (((uf + BYTTAB - 1) & (uchr) ~ BYTMASK) - uf);
i = (int) (((uf + BYTTAB - 1) & (uchr) ~BYTMASK) - uf);
for (; from <= to && i > 0; i--, from++)
newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
if (from > to) /* didn't reach a boundary */

10
src/backend/regex/regc_cvec.c
View File

@ -28,7 +28,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*/
@ -52,7 +52,7 @@ newcvec(int nchrs, /* to hold this many chrs... */
if (cv == NULL)
return NULL;
cv->chrspace = nchrs;
cv->chrs = (chr *) & cv->mcces[nmcces]; /* chrs just after MCCE
cv->chrs = (chr *) &cv->mcces[nmcces]; /* chrs just after MCCE
* ptrs */
cv->mccespace = nmcces;
cv->ranges = cv->chrs + nchrs + nmcces * (MAXMCCE + 1);
@ -71,7 +71,7 @@ clearcvec(struct cvec * cv)
assert(cv != NULL);
cv->nchrs = 0;
assert(cv->chrs == (chr *) & cv->mcces[cv->mccespace]);
assert(cv->chrs == (chr *) &cv->mcces[cv->mccespace]);
cv->nmcces = 0;
cv->nmccechrs = 0;
cv->nranges = 0;
@ -111,8 +111,8 @@ addrange(struct cvec * cv, /* character vector */
*/
static void
addmcce(struct cvec * cv, /* character vector */
chr * startp, /* beginning of text */
chr * endp) /* just past end of text */
chr *startp, /* beginning of text */
chr *endp) /* just past end of text */
{
int len;
int i;

10
src/backend/regex/regc_lex.c
View File

@ -28,7 +28,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regc_lex.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regc_lex.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*/
@ -201,8 +201,8 @@ prefixes(struct vars * v)
*/
static void
lexnest(struct vars * v,
chr * beginp, /* start of interpolation */
chr * endp) /* one past end of interpolation */
chr *beginp, /* start of interpolation */
chr *endp) /* one past end of interpolation */
{
assert(v->savenow == NULL); /* only one level of nesting */
v->savenow = v->now;
@ -1121,8 +1121,8 @@ newline(void)
*/
static chr
chrnamed(struct vars * v,
chr * startp, /* start of name */
chr * endp, /* just past end of name */
chr *startp, /* start of name */
chr *endp, /* just past end of name */
chr lastresort) /* what to return if name lookup fails */
{
celt c;

14
src/backend/regex/regc_locale.c
View File

@ -47,7 +47,7 @@
* permission to use and distribute the software in accordance with the
* terms specified in this license.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regc_locale.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regc_locale.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*/
/* ASCII character-name table */
@ -453,8 +453,8 @@ allmcces(struct vars * v, /* context */
*/
static celt
element(struct vars * v, /* context */
chr * startp, /* points to start of name */
chr * endp) /* points just past end of name */
chr *startp, /* points to start of name */
chr *endp) /* points just past end of name */
{
struct cname *cn;
size_t len;
@ -593,8 +593,8 @@ eclass(struct vars * v, /* context */
*/
static struct cvec *
cclass(struct vars * v, /* context */
chr * startp, /* where the name starts */
chr * endp, /* just past the end of the name */
chr *startp, /* where the name starts */
chr *endp, /* just past the end of the name */
int cases) /* case-independent? */
{
size_t len;
@ -804,7 +804,7 @@ allcases(struct vars * v, /* context */
* stop at embedded NULs!
*/
static int /* 0 for equal, nonzero for unequal */
cmp(const chr * x, const chr * y, /* strings to compare */
cmp(const chr *x, const chr *y, /* strings to compare */
size_t len) /* exact length of comparison */
{
return memcmp(VS(x), VS(y), len * sizeof(chr));
@ -819,7 +819,7 @@ cmp(const chr * x, const chr * y, /* strings to compare */
* stop at embedded NULs!
*/
static int /* 0 for equal, nonzero for unequal */
casecmp(const chr * x, const chr * y, /* strings to compare */
casecmp(const chr *x, const chr *y, /* strings to compare */
size_t len) /* exact length of comparison */
{
for (; len > 0; len--, x++, y++)

8
src/backend/regex/regcomp.c
View File

@ -28,7 +28,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regcomp.c,v 1.37 2003/08/04 00:43:21 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regcomp.c,v 1.38 2003/08/08 21:41:56 momjian Exp $
*
*/
@ -293,7 +293,7 @@ static struct fns functions = {
*/
int
pg_regcomp(regex_t *re,
const chr * string,
const chr *string,
size_t len,
int flags)
{
@ -1052,8 +1052,8 @@ parseqatom(struct vars * v,
/*
* prepare a general-purpose state skeleton
*
* ---> [s] ---prefix---> [begin] ---atom---> [end] ----rest---> [rp] /
* / [lp] ----> [s2] ----bypass---------------------
* ---> [s] ---prefix---> [begin] ---atom---> [end] ----rest---> [rp] / /
* [lp] ----> [s2] ----bypass---------------------
*
* where bypass is an empty, and prefix is some repetitions of atom
*/

30
src/backend/regex/rege_dfa.c
View File

@ -28,7 +28,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*/
@ -38,8 +38,8 @@
static chr * /* endpoint, or NULL */
longest(struct vars * v, /* used only for debug and exec flags */
struct dfa * d,
chr * start, /* where the match should start */
chr * stop, /* match must end at or before here */
chr *start, /* where the match should start */
chr *stop, /* match must end at or before here */
int *hitstopp) /* record whether hit v->stop, if non-NULL */
{
chr *cp;
@ -142,10 +142,10 @@ longest(struct vars * v, /* used only for debug and exec flags */
static chr * /* endpoint, or NULL */
shortest(struct vars * v,
struct dfa * d,
chr * start, /* where the match should start */
chr * min, /* match must end at or after here */
chr * max, /* match must end at or before here */
chr ** coldp, /* store coldstart pointer here, if
chr *start, /* where the match should start */
chr *min, /* match must end at or after here */
chr *max, /* match must end at or before here */
chr **coldp, /* store coldstart pointer here, if
* nonNULL */
int *hitstopp) /* record whether hit v->stop, if non-NULL */
{
@ -394,7 +394,7 @@ hash(unsigned *uv,
static struct sset *
initialize(struct vars * v, /* used only for debug flags */
struct dfa * d,
chr * start)
chr *start)
{
struct sset *ss;
int i;
@ -430,8 +430,8 @@ miss(struct vars * v, /* used only for debug flags */
struct dfa * d,
struct sset * css,
pcolor co,
chr * cp, /* next chr */
chr * start) /* where the attempt got started */
chr *cp, /* next chr */
chr *start) /* where the attempt got started */
{
struct cnfa *cnfa = d->cnfa;
int i;
@ -538,7 +538,7 @@ miss(struct vars * v, /* used only for debug flags */
static int /* predicate: constraint satisfied? */
lacon(struct vars * v,
struct cnfa * pcnfa, /* parent cnfa */
chr * cp,
chr *cp,
pcolor co) /* "color" of the lookahead constraint */
{
int n;
@ -571,8 +571,8 @@ lacon(struct vars * v,
static struct sset *
getvacant(struct vars * v, /* used only for debug flags */
struct dfa * d,
chr * cp,
chr * start)
chr *cp,
chr *start)
{
int i;
struct sset *ss;
@ -639,8 +639,8 @@ getvacant(struct vars * v, /* used only for debug flags */
static struct sset *
pickss(struct vars * v, /* used only for debug flags */
struct dfa * d,
chr * cp,
chr * start)
chr *cp,
chr *start)
{
int i;
struct sset *ss;

44
src/backend/regex/regexec.c
View File

@ -27,7 +27,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regexec.c,v 1.22 2003/08/04 00:43:21 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regexec.c,v 1.23 2003/08/08 21:41:56 momjian Exp $
*
*/
@ -166,9 +166,9 @@ static struct sset *pickss(struct vars *, struct dfa *, chr *, chr *);
*/
int
pg_regexec(regex_t *re,
const chr * string,
const chr *string,
size_t len,
rm_detail_t * details,
rm_detail_t *details,
size_t nmatch,
regmatch_t pmatch[],
int flags)
@ -399,7 +399,7 @@ cfindloop(struct vars * v,
struct colormap * cm,
struct dfa * d,
struct dfa * s,
chr ** coldp) /* where to put coldstart pointer */
chr **coldp) /* where to put coldstart pointer */
{
chr *begin;
chr *end;
@ -528,8 +528,8 @@ zapmem(struct vars * v,
static void
subset(struct vars * v,
struct subre * sub,
chr * begin,
chr * end)
chr *begin,
chr *end)
{
int n = sub->subno;
@ -548,8 +548,8 @@ subset(struct vars * v,
static int /* regexec return code */
dissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
assert(t != NULL);
MDEBUG(("dissect %ld-%ld\n", LOFF(begin), LOFF(end)));
@ -589,8 +589,8 @@ dissect(struct vars * v,
static int /* regexec return code */
condissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
struct dfa *d;
struct dfa *d2;
@ -671,8 +671,8 @@ condissect(struct vars * v,
static int /* regexec return code */
altdissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
struct dfa *d;
int i;
@ -706,8 +706,8 @@ altdissect(struct vars * v,
static int /* regexec return code */
cdissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
int er;
@ -754,8 +754,8 @@ cdissect(struct vars * v,
static int /* regexec return code */
ccondissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
struct dfa *d;
struct dfa *d2;
@ -855,8 +855,8 @@ ccondissect(struct vars * v,
static int /* regexec return code */
crevdissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
struct dfa *d;
struct dfa *d2;
@ -953,8 +953,8 @@ crevdissect(struct vars * v,
static int /* regexec return code */
cbrdissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
int i;
int n = t->subno;
@ -1020,8 +1020,8 @@ cbrdissect(struct vars * v,
static int /* regexec return code */
caltdissect(struct vars * v,
struct subre * t,
chr * begin, /* beginning of relevant substring */
chr * end) /* end of same */
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
struct dfa *d;
int er;

2
src/backend/rewrite/rewriteHandler.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.127 2003/08/04 02:40:03 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.128 2003/08/08 21:41:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/

6
src/backend/rewrite/rewriteManip.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.76 2003/08/04 02:40:03 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.77 2003/08/08 21:41:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -28,7 +28,7 @@ typedef struct
} checkExprHasAggs_context;
static bool checkExprHasAggs_walker(Node *node,
checkExprHasAggs_context * context);
checkExprHasAggs_context *context);
static bool checkExprHasSubLink_walker(Node *node, void *context);
static Relids offset_relid_set(Relids relids, int offset);
static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
@ -63,7 +63,7 @@ checkExprHasAggs(Node *node)
}
static bool
checkExprHasAggs_walker(Node *node, checkExprHasAggs_context * context)
checkExprHasAggs_walker(Node *node, checkExprHasAggs_context *context)
{
if (node == NULL)
return false;

20
src/backend/storage/freespace/freespace.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.20 2003/08/04 02:40:03 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.21 2003/08/08 21:41:59 momjian Exp $
*
*
* NOTES:
@ -236,10 +236,10 @@ static bool lookup_fsm_page_entry(FSMRelation *fsmrel, BlockNumber page,
int *outPageIndex);
static void compact_fsm_storage(void);
static void push_fsm_rels_after(FSMRelation *afterRel);
static void pack_incoming_pages(FSMPageData * newLocation, int newPages,
PageFreeSpaceInfo * pageSpaces, int nPages);
static void pack_existing_pages(FSMPageData * newLocation, int newPages,
FSMPageData * oldLocation, int oldPages);
static void pack_incoming_pages(FSMPageData *newLocation, int newPages,
PageFreeSpaceInfo *pageSpaces, int nPages);
static void pack_existing_pages(FSMPageData *newLocation, int newPages,
FSMPageData *oldLocation, int oldPages);
static int fsm_calc_request(FSMRelation *fsmrel);
static int fsm_calc_target_allocation(int myRequest);
static int fsm_current_chunks(FSMRelation *fsmrel);
@ -459,7 +459,7 @@ GetAvgFSMRequestSize(RelFileNode *rel)
void
RecordRelationFreeSpace(RelFileNode *rel,
int nPages,
PageFreeSpaceInfo * pageSpaces)
PageFreeSpaceInfo *pageSpaces)
{
FSMRelation *fsmrel;
@ -1560,8 +1560,8 @@ push_fsm_rels_after(FSMRelation *afterRel)
#define HISTOGRAM_BINS 64
static void
pack_incoming_pages(FSMPageData * newLocation, int newPages,
PageFreeSpaceInfo * pageSpaces, int nPages)
pack_incoming_pages(FSMPageData *newLocation, int newPages,
PageFreeSpaceInfo *pageSpaces, int nPages)
{
int histogram[HISTOGRAM_BINS];
int above,
@ -1630,8 +1630,8 @@ pack_incoming_pages(FSMPageData * newLocation, int newPages,
* so that we can copy data moving forward in the arrays without problem.
*/
static void
pack_existing_pages(FSMPageData * newLocation, int newPages,
FSMPageData * oldLocation, int oldPages)
pack_existing_pages(FSMPageData *newLocation, int newPages,
FSMPageData *oldLocation, int oldPages)
{
int histogram[HISTOGRAM_BINS];
int above,

2
src/backend/storage/lmgr/deadlock.c
View File

@ -12,7 +12,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.23 2003/08/04 02:40:03 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.24 2003/08/08 21:42:00 momjian Exp $
*
* Interface:
*

38
src/backend/storage/lmgr/s_lock.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.15 2003/08/06 16:43:43 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.16 2003/08/08 21:42:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -54,26 +54,27 @@ s_lock(volatile slock_t *lock, const char *file, int line)
* finish 100 iterations. However, on a uniprocessor, the tight loop
* is just a waste of cycles, so don't iterate thousands of times.
*
* Once we do decide to block, we use randomly increasing select() delays.
* The first delay is 10 msec, then the delay randomly increases to about
* one second, after which we reset to 10 msec and start again. The idea
* here is that in the presence of heavy contention we need to increase
* the delay, else the spinlock holder may never get to run and release
* the lock. (Consider situation where spinlock holder has been nice'd
* down in priority by the scheduler --- it will not get scheduled until
* all would-be acquirers are sleeping, so if we always use a 10-msec
* sleep, there is a real possibility of starvation.) But we can't just
* clamp the delay to an upper bound, else it would take a long time to
* make a reasonable number of tries.
* Once we do decide to block, we use randomly increasing select()
* delays. The first delay is 10 msec, then the delay randomly
* increases to about one second, after which we reset to 10 msec and
* start again. The idea here is that in the presence of heavy
* contention we need to increase the delay, else the spinlock holder
* may never get to run and release the lock. (Consider situation
* where spinlock holder has been nice'd down in priority by the
* scheduler --- it will not get scheduled until all would-be
* acquirers are sleeping, so if we always use a 10-msec sleep, there
* is a real possibility of starvation.) But we can't just clamp the
* delay to an upper bound, else it would take a long time to make a
* reasonable number of tries.
*
* We time out and declare error after NUM_DELAYS delays (thus, exactly
* that many tries). With the given settings, this will usually take
* 3 or so minutes. It seems better to fix the total number of tries (and
* thus the probability of unintended failure) than to fix the total time
* spent.
* 3 or so minutes. It seems better to fix the total number of tries
* (and thus the probability of unintended failure) than to fix the
* total time spent.
*
* The select() delays are measured in centiseconds (0.01 sec) because
* 10 msec is a common resolution limit at the OS level.
* The select() delays are measured in centiseconds (0.01 sec) because 10
* msec is a common resolution limit at the OS level.
*/
#define SPINS_PER_DELAY 100
#define NUM_DELAYS 1000
@ -97,7 +98,8 @@ s_lock(volatile slock_t *lock, const char *file, int line)
(void) select(0, NULL, NULL, NULL, &delay);
#if defined(S_LOCK_TEST)
fprintf(stdout, "*"); fflush(stdout);
fprintf(stdout, "*");
fflush(stdout);
#endif
/* increase delay by a random fraction between 1X and 2X */

8
src/backend/utils/adt/arrayfuncs.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.96 2003/08/04 02:40:04 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.97 2003/08/08 21:42:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -2989,7 +2989,7 @@ array_type_coerce(PG_FUNCTION_ARGS)
* rcontext is where to keep working state
*/
ArrayBuildState *
accumArrayResult(ArrayBuildState * astate,
accumArrayResult(ArrayBuildState *astate,
Datum dvalue, bool disnull,
Oid element_type,
MemoryContext rcontext)
@ -3051,7 +3051,7 @@ accumArrayResult(ArrayBuildState * astate,
* rcontext is where to construct result
*/
Datum
makeArrayResult(ArrayBuildState * astate,
makeArrayResult(ArrayBuildState *astate,
MemoryContext rcontext)
{
int dims[1];
@ -3073,7 +3073,7 @@ makeArrayResult(ArrayBuildState * astate,
* rcontext is where to construct result
*/
Datum
makeMdArrayResult(ArrayBuildState * astate,
makeMdArrayResult(ArrayBuildState *astate,
int ndims,
int *dims,
int *lbs,

2
src/backend/utils/adt/datetime.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.112 2003/08/05 18:30:21 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.113 2003/08/08 21:42:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/

4
src/backend/utils/adt/oracle_compat.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.47 2003/08/04 00:43:25 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.48 2003/08/08 21:42:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -872,7 +872,7 @@ ascii(PG_FUNCTION_ARGS)
********************************************************************/
Datum
chr(PG_FUNCTION_ARGS)
chr (PG_FUNCTION_ARGS)
{
int32 cvalue = PG_GETARG_INT32(0);
text *result;

2
src/backend/utils/adt/regexp.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.48 2003/08/04 02:40:05 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.49 2003/08/08 21:42:07 momjian Exp $
*
* Alistair Crooks added the code for the regex caching
* agc - cached the regular expressions used - there's a good chance

14
src/backend/utils/adt/ruleutils.c
View File

@ -3,7 +3,7 @@
* back to source text
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.149 2003/08/04 00:43:26 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.150 2003/08/08 21:42:09 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
@ -181,15 +181,15 @@ static void get_names_for_var(Var *var, deparse_context *context,
char **schemaname, char **refname, char **attname);
static RangeTblEntry *find_rte_by_refname(const char *refname,
deparse_context *context);
static const char *get_simple_binary_op_name(OpExpr * expr);
static const char *get_simple_binary_op_name(OpExpr *expr);
static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags);
static void appendStringInfoSpaces(StringInfo buf, int count);
static void appendContextKeyword(deparse_context *context, const char *str,
int indentBefore, int indentAfter, int indentPlus);
static void get_rule_expr(Node *node, deparse_context *context,
bool showimplicit);
static void get_oper_expr(OpExpr * expr, deparse_context *context);
static void get_func_expr(FuncExpr * expr, deparse_context *context,
static void get_oper_expr(OpExpr *expr, deparse_context *context);
static void get_func_expr(FuncExpr *expr, deparse_context *context,
bool showimplicit);
static void get_agg_expr(Aggref *aggref, deparse_context *context);
static Node *strip_type_coercion(Node *expr, Oid resultType);
@ -2439,7 +2439,7 @@ find_rte_by_refname(const char *refname, deparse_context *context)
* will return single char binary operator name, or NULL if it's not
*/
static const char *
get_simple_binary_op_name(OpExpr * expr)
get_simple_binary_op_name(OpExpr *expr)
{
List *args = expr->args;
@ -3235,7 +3235,7 @@ get_rule_expr(Node *node, deparse_context *context,
* get_oper_expr - Parse back an OpExpr node
*/
static void
get_oper_expr(OpExpr * expr, deparse_context *context)
get_oper_expr(OpExpr *expr, deparse_context *context)
{
StringInfo buf = context->buf;
Oid opno = expr->opno;
@ -3298,7 +3298,7 @@ get_oper_expr(OpExpr * expr, deparse_context *context)
* get_func_expr - Parse back a FuncExpr node
*/
static void
get_func_expr(FuncExpr * expr, deparse_context *context,
get_func_expr(FuncExpr *expr, deparse_context *context,
bool showimplicit)
{
StringInfo buf = context->buf;

2
src/backend/utils/adt/selfuncs.c
View File

@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.144 2003/08/04 02:40:05 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.145 2003/08/08 21:42:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/

7
src/backend/utils/adt/timestamp.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.91 2003/08/08 00:10:31 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.92 2003/08/08 21:42:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -1307,11 +1307,12 @@ timestamp_cmp_internal(Timestamp dt1, Timestamp dt2)
#ifdef HAVE_INT64_TIMESTAMP
return ((dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0));
#else
/*
* When using float representation, we have to be wary of NaNs.
*
* We consider all NANs to be equal and larger than any non-NAN. This
* is somewhat arbitrary; the important thing is to have a consistent
* We consider all NANs to be equal and larger than any non-NAN. This is
* somewhat arbitrary; the important thing is to have a consistent
* sort order.
*/
if (isnan(dt1))

14
src/backend/utils/error/elog.c
View File

@ -37,7 +37,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.118 2003/08/04 02:40:06 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.119 2003/08/08 21:42:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -138,9 +138,9 @@ static int recursion_depth = 0; /* to detect actual recursion */
} while (0)
static void send_message_to_server_log(ErrorData * edata);
static void send_message_to_frontend(ErrorData * edata);
static char *expand_fmt_string(const char *fmt, ErrorData * edata);
static void send_message_to_server_log(ErrorData *edata);
static void send_message_to_frontend(ErrorData *edata);
static char *expand_fmt_string(const char *fmt, ErrorData *edata);
static const char *useful_strerror(int errnum);
static const char *error_severity(int elevel);
static const char *print_timestamp(void);
@ -1024,7 +1024,7 @@ write_syslog(int level, const char *line)
* Write error report to server's log
*/
static void
send_message_to_server_log(ErrorData * edata)
send_message_to_server_log(ErrorData *edata)
{
StringInfoData buf;
@ -1151,7 +1151,7 @@ send_message_to_server_log(ErrorData * edata)
* Write error report to client
*/
static void
send_message_to_frontend(ErrorData * edata)
send_message_to_frontend(ErrorData *edata)
{
StringInfoData msgbuf;
@ -1289,7 +1289,7 @@ send_message_to_frontend(ErrorData * edata)
* The result is a palloc'd string.
*/
static char *
expand_fmt_string(const char *fmt, ErrorData * edata)
expand_fmt_string(const char *fmt, ErrorData *edata)
{
StringInfoData buf;
const char *cp;

14
src/backend/utils/misc/help_config.c
View File

@ -25,7 +25,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/misc/help_config.c,v 1.4 2003/08/04 00:43:27 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/misc/help_config.c,v 1.5 2003/08/08 21:42:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -121,7 +121,7 @@ typedef union
/* function prototypes */
static bool varMatches(mixedStruct * structToTest);
static bool varMatches(mixedStruct *structToTest);
static int compareMixedStructs(const void *, const void *);
static mixedStruct **varsToDisplay(int *resultListSize);
static const char *usageErrMsg(void);
@ -129,8 +129,8 @@ static void helpMessage(void);
static void listAllGroups(void);
static void printGenericHead(struct config_generic structToPrint);
static void printGenericFoot(struct config_generic structToPrint);
static void printMixedStruct(mixedStruct * structToPrint);
static bool displayStruct(mixedStruct * structToDisplay);
static void printMixedStruct(mixedStruct *structToPrint);
static bool displayStruct(mixedStruct *structToDisplay);
/*
@ -275,7 +275,7 @@ varsToDisplay(int *resultListSize)
* + It's flag bits are set to GUC_DISALLOW_IN_FILE
*/
static bool
displayStruct(mixedStruct * structToDisplay)
displayStruct(mixedStruct *structToDisplay)
{
if (structToDisplay->generic.flags & (GUC_NO_SHOW_ALL |
GUC_NOT_IN_SAMPLE |
@ -292,7 +292,7 @@ displayStruct(mixedStruct * structToDisplay)
* be returned to the user.
*/
static bool
varMatches(mixedStruct * structToTest)
varMatches(mixedStruct *structToTest)
{
bool matches = false;
bool specificSearch = false; /* This is true if the user
@ -347,7 +347,7 @@ varMatches(mixedStruct * structToTest)
* a different format, depending on what the user wants to see.
*/
static void
printMixedStruct(mixedStruct * structToPrint)
printMixedStruct(mixedStruct *structToPrint)
{
printGenericHead(structToPrint->generic);

6
src/bin/psql/common.c
View File

@ -3,7 +3,7 @@
*
* Copyright (c) 2000-2003, PostgreSQL Global Development Group
*
* $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.70 2003/08/04 23:59:39 tgl Exp $
* $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.71 2003/08/08 21:42:24 momjian Exp $
*/
#include "postgres_fe.h"
#include "common.h"
@ -487,8 +487,8 @@ PrintQueryTuples(const PGresult *results)
*/
static bool
PrintQueryResults(PGresult *results,
const TimevalStruct * before,
const TimevalStruct * after)
const TimevalStruct *before,
const TimevalStruct *after)
{
bool success = false;

4
src/include/access/genam.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: genam.h,v 1.42 2003/08/04 02:40:10 momjian Exp $
* $Id: genam.h,v 1.43 2003/08/08 21:42:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -89,7 +89,7 @@ extern IndexBulkDeleteResult *index_bulk_delete(Relation indexRelation,
IndexBulkDeleteCallback callback,
void *callback_state);
extern IndexBulkDeleteResult *index_vacuum_cleanup(Relation indexRelation,
IndexVacuumCleanupInfo * info,
IndexVacuumCleanupInfo *info,
IndexBulkDeleteResult *stats);
extern RegProcedure index_cost_estimator(Relation indexRelation);
extern RegProcedure index_getprocid(Relation irel, AttrNumber attnum,

2
src/include/access/nbtree.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: nbtree.h,v 1.69 2003/08/04 02:40:10 momjian Exp $
* $Id: nbtree.h,v 1.70 2003/08/08 21:42:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/include/access/slru.h
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: slru.h,v 1.2 2003/08/04 00:43:30 momjian Exp $
* $Id: slru.h,v 1.3 2003/08/08 21:42:32 momjian Exp $
*/
#ifndef SLRU_H
#define SLRU_H

2
src/include/access/xact.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: xact.h,v 1.54 2003/08/04 02:40:10 momjian Exp $
* $Id: xact.h,v 1.55 2003/08/08 21:42:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/include/catalog/pg_constraint.h
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: pg_constraint.h,v 1.8 2003/08/04 02:40:12 momjian Exp $
* $Id: pg_constraint.h,v 1.9 2003/08/08 21:42:32 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki

4
src/include/commands/portalcmds.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: portalcmds.h,v 1.12 2003/08/04 02:40:13 momjian Exp $
* $Id: portalcmds.h,v 1.13 2003/08/08 21:42:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -17,7 +17,7 @@
#include "utils/portal.h"
extern void PerformCursorOpen(DeclareCursorStmt * stmt);
extern void PerformCursorOpen(DeclareCursorStmt *stmt);
extern void PerformPortalFetch(FetchStmt *stmt, DestReceiver *dest,
char *completionTag);

4
src/include/commands/prepare.h
View File

@ -6,7 +6,7 @@
*
* Copyright (c) 2002-2003, PostgreSQL Global Development Group
*
* $Id: prepare.h,v 1.7 2003/08/04 00:43:30 momjian Exp $
* $Id: prepare.h,v 1.8 2003/08/08 21:42:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -57,6 +57,6 @@ extern PreparedStatement *FetchPreparedStatement(const char *stmt_name,
bool throwError);
extern void DropPreparedStatement(const char *stmt_name, bool showError);
extern List *FetchPreparedStatementParams(const char *stmt_name);
extern TupleDesc FetchPreparedStatementResultDesc(PreparedStatement * stmt);
extern TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt);
#endif /* PREPARE_H */

4
src/include/commands/sequence.h
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: sequence.h,v 1.25 2003/08/04 02:40:13 momjian Exp $
* $Id: sequence.h,v 1.26 2003/08/08 21:42:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -84,7 +84,7 @@ extern Datum setval(PG_FUNCTION_ARGS);
extern Datum setval_and_iscalled(PG_FUNCTION_ARGS);
extern void DefineSequence(CreateSeqStmt *stmt);
extern void AlterSequence(AlterSeqStmt * stmt);
extern void AlterSequence(AlterSeqStmt *stmt);
extern void seq_redo(XLogRecPtr lsn, XLogRecord *rptr);
extern void seq_undo(XLogRecPtr lsn, XLogRecord *rptr);

62
src/include/executor/executor.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: executor.h,v 1.98 2003/08/04 02:40:13 momjian Exp $
* $Id: executor.h,v 1.99 2003/08/08 21:42:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -31,9 +31,9 @@
/*
* prototypes from functions in execAmi.c
*/
extern void ExecReScan(PlanState * node, ExprContext *exprCtxt);
extern void ExecMarkPos(PlanState * node);
extern void ExecRestrPos(PlanState * node);
extern void ExecReScan(PlanState *node, ExprContext *exprCtxt);
extern void ExecMarkPos(PlanState *node);
extern void ExecRestrPos(PlanState *node);
extern bool ExecSupportsMarkRestore(NodeTag plantype);
extern bool ExecSupportsBackwardScan(Plan *node);
@ -72,7 +72,7 @@ extern TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable,
TupleTableSlot *slot,
bool *isnew);
extern TupleHashEntry ScanTupleHashTable(TupleHashTable hashtable,
TupleHashIterator * state);
TupleHashIterator *state);
/*
* prototypes from functions in execJunk.c
@ -93,7 +93,7 @@ extern TupleTableSlot *ExecutorRun(QueryDesc *queryDesc,
extern void ExecutorEnd(QueryDesc *queryDesc);
extern void ExecutorRewind(QueryDesc *queryDesc);
extern void ExecCheckRTPerms(List *rangeTable, CmdType operation);
extern void ExecEndPlan(PlanState * planstate, EState *estate);
extern void ExecEndPlan(PlanState *planstate, EState *estate);
extern void ExecConstraints(ResultRelInfo *resultRelInfo,
TupleTableSlot *slot, EState *estate);
extern TupleTableSlot *EvalPlanQual(EState *estate, Index rti,
@ -103,9 +103,9 @@ extern TupleTableSlot *EvalPlanQual(EState *estate, Index rti,
* prototypes from functions in execProcnode.c
*/
extern PlanState *ExecInitNode(Plan *node, EState *estate);
extern TupleTableSlot *ExecProcNode(PlanState * node);
extern TupleTableSlot *ExecProcNode(PlanState *node);
extern int ExecCountSlotsNode(Plan *node);
extern void ExecEndNode(PlanState * node);
extern void ExecEndNode(PlanState *node);
/*
* prototypes from functions in execQual.c
@ -114,22 +114,22 @@ extern Datum GetAttributeByNum(TupleTableSlot *slot, AttrNumber attrno,
bool *isNull);
extern Datum GetAttributeByName(TupleTableSlot *slot, char *attname,
bool *isNull);
extern void init_fcache(Oid foid, FuncExprState * fcache,
extern void init_fcache(Oid foid, FuncExprState *fcache,
MemoryContext fcacheCxt);
extern Datum ExecMakeFunctionResult(FuncExprState * fcache,
extern Datum ExecMakeFunctionResult(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone);
extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState * funcexpr,
extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState *funcexpr,
ExprContext *econtext,
TupleDesc expectedDesc,
TupleDesc *returnDesc);
extern Datum ExecEvalExpr(ExprState * expression, ExprContext *econtext,
extern Datum ExecEvalExpr(ExprState *expression, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
extern Datum ExecEvalExprSwitchContext(ExprState * expression, ExprContext *econtext,
extern Datum ExecEvalExprSwitchContext(ExprState *expression, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
extern ExprState *ExecInitExpr(Expr *node, PlanState * parent);
extern SubPlanState *ExecInitExprInitPlan(SubPlan *node, PlanState * parent);
extern ExprState *ExecInitExpr(Expr *node, PlanState *parent);
extern SubPlanState *ExecInitExprInitPlan(SubPlan *node, PlanState *parent);
extern ExprState *ExecPrepareExpr(Expr *node, EState *estate);
extern bool ExecQual(List *qual, ExprContext *econtext, bool resultForNull);
extern int ExecTargetListLength(List *targetlist);
@ -140,10 +140,10 @@ extern TupleTableSlot *ExecProject(ProjectionInfo *projInfo,
/*
* prototypes from functions in execScan.c
*/
typedef TupleTableSlot *(*ExecScanAccessMtd) (ScanState * node);
typedef TupleTableSlot *(*ExecScanAccessMtd) (ScanState *node);
extern TupleTableSlot *ExecScan(ScanState * node, ExecScanAccessMtd accessMtd);
extern void ExecAssignScanProjectionInfo(ScanState * node);
extern TupleTableSlot *ExecScan(ScanState *node, ExecScanAccessMtd accessMtd);
extern void ExecAssignScanProjectionInfo(ScanState *node);
/*
* prototypes from functions in execTuples.c
@ -160,14 +160,14 @@ extern TupleTableSlot *ExecClearTuple(TupleTableSlot *slot);
extern void ExecSetSlotDescriptor(TupleTableSlot *slot,
TupleDesc tupdesc, bool shouldFree);
extern void ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, bool isNew);
extern void ExecInitResultTupleSlot(EState *estate, PlanState * planstate);
extern void ExecInitScanTupleSlot(EState *estate, ScanState * scanstate);
extern void ExecInitResultTupleSlot(EState *estate, PlanState *planstate);
extern void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate);
extern TupleTableSlot *ExecInitExtraTupleSlot(EState *estate);
extern TupleTableSlot *ExecInitNullTupleSlot(EState *estate,
TupleDesc tupType);
extern TupleDesc ExecTypeFromTL(List *targetList, bool hasoid);
extern TupleDesc ExecCleanTypeFromTL(List *targetList, bool hasoid);
extern void UpdateChangedParamSet(PlanState * node, Bitmapset * newchg);
extern void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg);
typedef struct TupOutputState
{
@ -224,21 +224,21 @@ extern ExprContext *MakePerTupleExprContext(EState *estate);
ResetExprContext((estate)->es_per_tuple_exprcontext); \
} while (0)
extern void ExecAssignExprContext(EState *estate, PlanState * planstate);
extern void ExecAssignResultType(PlanState * planstate,
extern void ExecAssignExprContext(EState *estate, PlanState *planstate);
extern void ExecAssignResultType(PlanState *planstate,
TupleDesc tupDesc, bool shouldFree);
extern void ExecAssignResultTypeFromOuterPlan(PlanState * planstate);
extern void ExecAssignResultTypeFromTL(PlanState * planstate);
extern TupleDesc ExecGetResultType(PlanState * planstate);
extern void ExecAssignResultTypeFromOuterPlan(PlanState *planstate);
extern void ExecAssignResultTypeFromTL(PlanState *planstate);
extern TupleDesc ExecGetResultType(PlanState *planstate);
extern ProjectionInfo *ExecBuildProjectionInfo(List *targetList,
ExprContext *econtext,
TupleTableSlot *slot);
extern void ExecAssignProjectionInfo(PlanState * planstate);
extern void ExecFreeExprContext(PlanState * planstate);
extern TupleDesc ExecGetScanType(ScanState * scanstate);
extern void ExecAssignScanType(ScanState * scanstate,
extern void ExecAssignProjectionInfo(PlanState *planstate);
extern void ExecFreeExprContext(PlanState *planstate);
extern TupleDesc ExecGetScanType(ScanState *scanstate);
extern void ExecAssignScanType(ScanState *scanstate,
TupleDesc tupDesc, bool shouldFree);
extern void ExecAssignScanTypeFromOuterPlan(ScanState * scanstate);
extern void ExecAssignScanTypeFromOuterPlan(ScanState *scanstate);
extern void ExecOpenIndices(ResultRelInfo *resultRelInfo);
extern void ExecCloseIndices(ResultRelInfo *resultRelInfo);

12
src/include/executor/nodeSeqscan.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: nodeSeqscan.h,v 1.18 2003/08/04 02:40:13 momjian Exp $
* $Id: nodeSeqscan.h,v 1.19 2003/08/08 21:42:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -18,10 +18,10 @@
extern int ExecCountSlotsSeqScan(SeqScan *node);
extern SeqScanState *ExecInitSeqScan(SeqScan *node, EState *estate);
extern TupleTableSlot *ExecSeqScan(SeqScanState * node);
extern void ExecEndSeqScan(SeqScanState * node);
extern void ExecSeqMarkPos(SeqScanState * node);
extern void ExecSeqRestrPos(SeqScanState * node);
extern void ExecSeqReScan(SeqScanState * node, ExprContext *exprCtxt);
extern TupleTableSlot *ExecSeqScan(SeqScanState *node);
extern void ExecEndSeqScan(SeqScanState *node);
extern void ExecSeqMarkPos(SeqScanState *node);
extern void ExecSeqRestrPos(SeqScanState *node);
extern void ExecSeqReScan(SeqScanState *node, ExprContext *exprCtxt);
#endif /* NODESEQSCAN_H */

12
src/include/executor/nodeSubplan.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: nodeSubplan.h,v 1.17 2003/08/04 02:40:13 momjian Exp $
* $Id: nodeSubplan.h,v 1.18 2003/08/08 21:42:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,13 +16,13 @@
#include "nodes/execnodes.h"
extern void ExecInitSubPlan(SubPlanState * node, EState *estate);
extern Datum ExecSubPlan(SubPlanState * node,
extern void ExecInitSubPlan(SubPlanState *node, EState *estate);
extern Datum ExecSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull);
extern void ExecEndSubPlan(SubPlanState * node);
extern void ExecReScanSetParamPlan(SubPlanState * node, PlanState * parent);
extern void ExecEndSubPlan(SubPlanState *node);
extern void ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent);
extern void ExecSetParamPlan(SubPlanState * node, ExprContext *econtext);
extern void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext);
#endif /* NODESUBPLAN_H */

5
src/include/getaddrinfo.h
View File

@ -15,7 +15,7 @@
*
* Copyright (c) 2003, PostgreSQL Global Development Group
*
* $Id: getaddrinfo.h,v 1.9 2003/08/07 16:45:21 tgl Exp $
* $Id: getaddrinfo.h,v 1.10 2003/08/08 21:42:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -41,7 +41,6 @@
#define EAI_SERVICE -8
#define EAI_MEMORY -10
#define EAI_SYSTEM -11
#endif
#ifndef AI_PASSIVE
@ -79,7 +78,6 @@ struct addrinfo
char *ai_canonname;
struct addrinfo *ai_next;
};
#endif /* HAVE_STRUCT_ADDRINFO */
@ -113,7 +111,6 @@ extern const char *gai_strerror(int errcode);
extern int getnameinfo(const struct sockaddr * sa, int salen,
char *node, int nodelen,
char *service, int servicelen, int flags);
#endif /* HAVE_GETADDRINFO */
#endif /* GETADDRINFO_H */

4
src/include/getopt_long.h
View File

@ -4,7 +4,7 @@
*
* Portions Copyright (c) 2003, PostgreSQL Global Development Group
*
* $Header: /cvsroot/pgsql/src/include/getopt_long.h,v 1.3 2003/08/07 21:11:58 tgl Exp $
* $Header: /cvsroot/pgsql/src/include/getopt_long.h,v 1.4 2003/08/08 21:42:31 momjian Exp $
*/
#ifndef GETOPT_LONG_H
#define GETOPT_LONG_H
@ -34,7 +34,6 @@ struct option
#define no_argument 0
#define required_argument 1
#endif
#ifndef HAVE_GETOPT_LONG
@ -42,7 +41,6 @@ struct option
extern int getopt_long(int argc, char *const argv[],
const char *optstring,
const struct option * longopts, int *longindex);
#endif
#endif /* GETOPT_LONG_H */

44
src/include/nodes/bitmapset.h
View File

@ -13,7 +13,7 @@
*
* Copyright (c) 2003, PostgreSQL Global Development Group
*
* $Id: bitmapset.h,v 1.3 2003/08/04 00:43:31 momjian Exp $
* $Id: bitmapset.h,v 1.4 2003/08/08 21:42:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -49,35 +49,35 @@ typedef enum
* function prototypes in nodes/bitmapset.c
*/
extern Bitmapset *bms_copy(const Bitmapset * a);
extern bool bms_equal(const Bitmapset * a, const Bitmapset * b);
extern Bitmapset *bms_copy(const Bitmapset *a);
extern bool bms_equal(const Bitmapset *a, const Bitmapset *b);
extern Bitmapset *bms_make_singleton(int x);
extern void bms_free(Bitmapset * a);
extern void bms_free(Bitmapset *a);
extern Bitmapset *bms_union(const Bitmapset * a, const Bitmapset * b);
extern Bitmapset *bms_intersect(const Bitmapset * a, const Bitmapset * b);
extern Bitmapset *bms_difference(const Bitmapset * a, const Bitmapset * b);
extern bool bms_is_subset(const Bitmapset * a, const Bitmapset * b);
extern bool bms_is_member(int x, const Bitmapset * a);
extern bool bms_overlap(const Bitmapset * a, const Bitmapset * b);
extern bool bms_nonempty_difference(const Bitmapset * a, const Bitmapset * b);
extern int bms_singleton_member(const Bitmapset * a);
extern int bms_num_members(const Bitmapset * a);
extern Bitmapset *bms_union(const Bitmapset *a, const Bitmapset *b);
extern Bitmapset *bms_intersect(const Bitmapset *a, const Bitmapset *b);
extern Bitmapset *bms_difference(const Bitmapset *a, const Bitmapset *b);
extern bool bms_is_subset(const Bitmapset *a, const Bitmapset *b);
extern bool bms_is_member(int x, const Bitmapset *a);
extern bool bms_overlap(const Bitmapset *a, const Bitmapset *b);
extern bool bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b);
extern int bms_singleton_member(const Bitmapset *a);
extern int bms_num_members(const Bitmapset *a);
/* optimized tests when we don't need to know exact membership count: */
extern BMS_Membership bms_membership(const Bitmapset * a);
extern bool bms_is_empty(const Bitmapset * a);
extern BMS_Membership bms_membership(const Bitmapset *a);
extern bool bms_is_empty(const Bitmapset *a);
/* these routines recycle (modify or free) their non-const inputs: */
extern Bitmapset *bms_add_member(Bitmapset * a, int x);
extern Bitmapset *bms_del_member(Bitmapset * a, int x);
extern Bitmapset *bms_add_members(Bitmapset * a, const Bitmapset * b);
extern Bitmapset *bms_int_members(Bitmapset * a, const Bitmapset * b);
extern Bitmapset *bms_del_members(Bitmapset * a, const Bitmapset * b);
extern Bitmapset *bms_join(Bitmapset * a, Bitmapset * b);
extern Bitmapset *bms_add_member(Bitmapset *a, int x);
extern Bitmapset *bms_del_member(Bitmapset *a, int x);
extern Bitmapset *bms_add_members(Bitmapset *a, const Bitmapset *b);
extern Bitmapset *bms_int_members(Bitmapset *a, const Bitmapset *b);
extern Bitmapset *bms_del_members(Bitmapset *a, const Bitmapset *b);
extern Bitmapset *bms_join(Bitmapset *a, Bitmapset *b);
/* support for iterating through the integer elements of a set: */
extern int bms_first_member(Bitmapset * a);
extern int bms_first_member(Bitmapset *a);
#endif /* BITMAPSET_H */

2
src/include/nodes/execnodes.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: execnodes.h,v 1.102 2003/08/04 02:40:13 momjian Exp $
* $Id: execnodes.h,v 1.103 2003/08/08 21:42:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/include/nodes/parsenodes.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: parsenodes.h,v 1.245 2003/08/04 02:40:13 momjian Exp $
* $Id: parsenodes.h,v 1.246 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/

12
src/include/nodes/pg_list.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: pg_list.h,v 1.39 2003/08/04 02:40:13 momjian Exp $
* $Id: pg_list.h,v 1.40 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -160,11 +160,11 @@ extern List *lappend(List *list, void *datum);
extern List *lappendi(List *list, int datum);
extern List *lappendo(List *list, Oid datum);
extern List *nconc(List *list1, List *list2);
extern void FastAppend(FastList * fl, void *datum);
extern void FastAppendi(FastList * fl, int datum);
extern void FastAppendo(FastList * fl, Oid datum);
extern void FastConc(FastList * fl, List *cells);
extern void FastConcFast(FastList * fl, FastList * fl2);
extern void FastAppend(FastList *fl, void *datum);
extern void FastAppendi(FastList *fl, int datum);
extern void FastAppendo(FastList *fl, Oid datum);
extern void FastConc(FastList *fl, List *cells);
extern void FastConcFast(FastList *fl, FastList *fl2);
extern void *nth(int n, List *l);
extern int length(List *list);
extern void *llast(List *list);

2
src/include/nodes/plannodes.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: plannodes.h,v 1.67 2003/08/04 02:40:13 momjian Exp $
* $Id: plannodes.h,v 1.68 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/include/nodes/primnodes.h
View File

@ -10,7 +10,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: primnodes.h,v 1.89 2003/08/04 02:40:13 momjian Exp $
* $Id: primnodes.h,v 1.90 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/include/nodes/relation.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: relation.h,v 1.84 2003/08/04 02:40:13 momjian Exp $
* $Id: relation.h,v 1.85 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/

4
src/include/optimizer/clauses.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: clauses.h,v 1.67 2003/08/04 02:40:13 momjian Exp $
* $Id: clauses.h,v 1.68 2003/08/08 21:42:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -60,7 +60,7 @@ extern bool has_distinct_on_clause(Query *query);
extern void clause_get_relids_vars(Node *clause, Relids *relids, List **vars);
extern int NumRelids(Node *clause);
extern void CommuteClause(OpExpr * clause);
extern void CommuteClause(OpExpr *clause);
extern Node *eval_const_expressions(Node *node);

4
src/include/optimizer/cost.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: cost.h,v 1.56 2003/08/04 02:40:13 momjian Exp $
* $Id: cost.h,v 1.57 2003/08/08 21:42:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -75,7 +75,7 @@ extern void cost_group(Path *path, Query *root,
extern void cost_nestloop(NestPath *path, Query *root);
extern void cost_mergejoin(MergePath *path, Query *root);
extern void cost_hashjoin(HashPath *path, Query *root);
extern void cost_qual_eval(QualCost * cost, List *quals);
extern void cost_qual_eval(QualCost *cost, List *quals);
extern void set_baserel_size_estimates(Query *root, RelOptInfo *rel);
extern void set_joinrel_size_estimates(Query *root, RelOptInfo *rel,
RelOptInfo *outer_rel,

4
src/include/optimizer/planmain.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: planmain.h,v 1.74 2003/08/04 02:40:14 momjian Exp $
* $Id: planmain.h,v 1.75 2003/08/08 21:42:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -69,6 +69,6 @@ extern void process_implied_equality(Query *root,
*/
extern void set_plan_references(Plan *plan, List *rtable);
extern void fix_opfuncids(Node *node);
extern void set_opfuncid(OpExpr * opexpr);
extern void set_opfuncid(OpExpr *opexpr);
#endif /* PLANMAIN_H */

2
src/include/port.h
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: port.h,v 1.11 2003/08/08 04:52:22 momjian Exp $
* $Id: port.h,v 1.12 2003/08/08 21:42:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/include/regex/regex.h
View File

@ -29,7 +29,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Id: regex.h,v 1.24 2003/08/04 00:43:32 momjian Exp $
* $Id: regex.h,v 1.25 2003/08/08 21:42:51 momjian Exp $
*/
/*

4
src/include/storage/freespace.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: freespace.h,v 1.12 2003/08/04 02:40:14 momjian Exp $
* $Id: freespace.h,v 1.13 2003/08/08 21:42:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -47,7 +47,7 @@ extern BlockNumber RecordAndGetPageWithFreeSpace(RelFileNode *rel,
extern Size GetAvgFSMRequestSize(RelFileNode *rel);
extern void RecordRelationFreeSpace(RelFileNode *rel,
int nPages,
PageFreeSpaceInfo * pageSpaces);
PageFreeSpaceInfo *pageSpaces);
extern BlockNumber GetFreeIndexPage(RelFileNode *rel);
extern void RecordIndexFreeSpace(RelFileNode *rel,

2
src/include/tcop/dest.h
View File

@ -54,7 +54,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: dest.h,v 1.41 2003/08/06 17:46:46 tgl Exp $
* $Id: dest.h,v 1.42 2003/08/08 21:42:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/

2
src/include/utils/acl.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: acl.h,v 1.60 2003/08/04 02:40:15 momjian Exp $
* $Id: acl.h,v 1.61 2003/08/08 21:42:55 momjian Exp $
*
* NOTES
* For backward-compatibility purposes we have to allow there

8
src/include/utils/array.h
View File

@ -10,7 +10,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: array.h,v 1.44 2003/08/04 02:40:15 momjian Exp $
* $Id: array.h,v 1.45 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -160,13 +160,13 @@ extern void deconstruct_array(ArrayType *array,
Oid elmtype,
int elmlen, bool elmbyval, char elmalign,
Datum **elemsp, int *nelemsp);
extern ArrayBuildState *accumArrayResult(ArrayBuildState * astate,
extern ArrayBuildState *accumArrayResult(ArrayBuildState *astate,
Datum dvalue, bool disnull,
Oid element_type,
MemoryContext rcontext);
extern Datum makeArrayResult(ArrayBuildState * astate,
extern Datum makeArrayResult(ArrayBuildState *astate,
MemoryContext rcontext);
extern Datum makeMdArrayResult(ArrayBuildState * astate, int ndims,
extern Datum makeMdArrayResult(ArrayBuildState *astate, int ndims,
int *dims, int *lbs, MemoryContext rcontext);
/*

Some files were not shown because too many files have changed in this diff Show More