database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-02 09:02:37 +03:00
Code Activity

Another pgindent run with updated typedefs.

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

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;

8
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 $
*
*-------------------------------------------------------------------------
*/
@ -173,7 +173,7 @@ typedef struct AggStatePerGroupData
* later input value. Only the first non-NULL input will be
* auto-substituted.
*/
} AggStatePerGroupData;
} AggStatePerGroupData;
/*
* To implement hashed aggregation, we need a hashtable that stores a
@ -188,7 +188,7 @@ typedef struct AggHashEntryData
TupleHashEntryData shared; /* common header for hash table entries */
/* per-aggregate transition status array - must be last! */
AggStatePerGroupData pergroup[1]; /* VARIABLE LENGTH ARRAY */
} AggHashEntryData; /* VARIABLE LENGTH STRUCT */
} AggHashEntryData; /* VARIABLE LENGTH STRUCT */
static void initialize_aggregates(AggState *aggstate,
@ -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;

11
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 $
*
*-------------------------------------------------------------------------
*/
@ -1263,7 +1263,7 @@ static void
_SPI_cursor_operation(Portal portal, bool forward, int count,
DestReceiver *dest)
{
long nfetched;
long nfetched;
/* Check that the portal is valid */
if (!PortalIsValid(portal))
@ -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;

4
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 $
*
*-------------------------------------------------------------------------
*/
@ -24,7 +24,7 @@ typedef struct
DestReceiver pub;
Tuplestorestate *tstore;
MemoryContext cxt;
} TStoreState;
} TStoreState;
/*