database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-30 21:42:05 +03:00
Code Activity

Used modified version of indent that understands over 100 typedefs.

Browse Source
This commit is contained in:
Bruce Momjian
1997-09-08 21:56:23 +00:00
parent 075cede748
commit 59f6a57e59
413 changed files with 4472 additions and 4460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.7 1997/09/08 02:22:23 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.8 1997/09/08 21:42:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -71,8 +71,8 @@ ExecOpenScanR(Oid relOid,
bool isindex,
ScanDirection dir,
TimeQual timeRange,
Relation * returnRelation, /* return */
Pointer * returnScanDesc) /* return */
Relation *returnRelation, /* return */
Pointer *returnScanDesc) /* return */
{
Relation relation;
Pointer scanDesc;
@ -195,7 +195,7 @@ ExecBeginScan(Relation relation,
* ----------------------------------------------------------------
*/
void
ExecCloseR(Plan * node)
ExecCloseR(Plan *node)
{
CommonScanState *state;
Relation relation;
@ -288,7 +288,7 @@ ExecCloseR(Plan * node)
* ----------------------------------------------------------------
*/
void
ExecReScan(Plan * node, ExprContext * exprCtxt, Plan * parent)
ExecReScan(Plan *node, ExprContext *exprCtxt, Plan *parent)
{
switch (nodeTag(node))
{
@ -328,7 +328,7 @@ ExecReScan(Plan * node, ExprContext * exprCtxt, Plan * parent)
* ----------------------------------------------------------------
*/
HeapScanDesc
ExecReScanR(Relation relDesc, /* LLL relDesc unused */
ExecReScanR(Relation relDesc, /* LLL relDesc unused */
HeapScanDesc scanDesc,
ScanDirection direction,
int nkeys, /* LLL nkeys unused */
@ -351,7 +351,7 @@ ExecReScanR(Relation relDesc, /* LLL relDesc unused */
* ----------------------------------------------------------------
*/
void
ExecMarkPos(Plan * node)
ExecMarkPos(Plan *node)
{
switch (nodeTag(node))
{
@ -381,7 +381,7 @@ ExecMarkPos(Plan * node)
* ----------------------------------------------------------------
*/
void
ExecRestrPos(Plan * node)
ExecRestrPos(Plan *node)
{
switch (nodeTag(node))
{

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

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/execFlatten.c,v 1.4 1997/09/08 02:22:25 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/execFlatten.c,v 1.5 1997/09/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -34,16 +34,16 @@
#ifdef SETS_FIXED
static bool
FjoinBumpOuterNodes(TargetEntry * tlist, ExprContext * econtext,
FjoinBumpOuterNodes(TargetEntry *tlist, ExprContext *econtext,
DatumPtr results, char *nulls);
#endif
Datum
ExecEvalIter(Iter * iterNode,
ExprContext * econtext,
bool * resultIsNull,
bool * iterIsDone)
ExecEvalIter(Iter *iterNode,
ExprContext *econtext,
bool *resultIsNull,
bool *iterIsDone)
{
Node *expression;
@ -59,10 +59,10 @@ ExecEvalIter(Iter * iterNode,
}
void
ExecEvalFjoin(TargetEntry * tlist,
ExprContext * econtext,
bool * isNullVect,
bool * fj_isDone)
ExecEvalFjoin(TargetEntry *tlist,
ExprContext *econtext,
bool *isNullVect,
bool *fj_isDone)
{
#ifdef SETS_FIXED
@ -182,8 +182,8 @@ ExecEvalFjoin(TargetEntry * tlist,
#ifdef SETS_FIXED
static bool
FjoinBumpOuterNodes(TargetEntry * tlist,
ExprContext * econtext,
FjoinBumpOuterNodes(TargetEntry *tlist,
ExprContext *econtext,
DatumPtr results,
char *nulls)
{

14
src/backend/executor/execJunk.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execJunk.c,v 1.7 1997/09/08 02:22:27 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execJunk.c,v 1.8 1997/09/08 21:42:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -61,7 +61,7 @@
*-------------------------------------------------------------------------
*/
JunkFilter *
ExecInitJunkFilter(List * targetList)
ExecInitJunkFilter(List *targetList)
{
JunkFilter *junkfilter;
List *cleanTargetList;
@ -264,11 +264,11 @@ ExecInitJunkFilter(List * targetList)
*-------------------------------------------------------------------------
*/
bool
ExecGetJunkAttribute(JunkFilter * junkfilter,
TupleTableSlot * slot,
ExecGetJunkAttribute(JunkFilter *junkfilter,
TupleTableSlot *slot,
char *attrName,
Datum * value,
bool * isNull)
Datum *value,
bool *isNull)
{
List *targetList;
List *t;
@ -328,7 +328,7 @@ ExecGetJunkAttribute(JunkFilter * junkfilter,
*-------------------------------------------------------------------------
*/
HeapTuple
ExecRemoveJunk(JunkFilter * junkfilter, TupleTableSlot * slot)
ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot)
{
HeapTuple tuple;
HeapTuple cleanTuple;

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

@ -26,7 +26,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.24 1997/09/08 02:22:28 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.25 1997/09/08 21:42:57 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -57,28 +57,28 @@
/* decls for local routines only used within this module */
static void
ExecCheckPerms(CmdType operation, int resultRelation, List * rangeTable,
Query * parseTree);
ExecCheckPerms(CmdType operation, int resultRelation, List *rangeTable,
Query *parseTree);
static TupleDesc
InitPlan(CmdType operation, Query * parseTree,
Plan * plan, EState * estate);
static void EndPlan(Plan * plan, EState * estate);
InitPlan(CmdType operation, Query *parseTree,
Plan *plan, EState *estate);
static void EndPlan(Plan *plan, EState *estate);
static TupleTableSlot *
ExecutePlan(EState * estate, Plan * plan,
Query * parseTree, CmdType operation,
ExecutePlan(EState *estate, Plan *plan,
Query *parseTree, CmdType operation,
int numberTuples, ScanDirection direction,
void (*printfunc) ());
static void ExecRetrieve(TupleTableSlot * slot, void (*printfunc) (),
EState * estate);
static void ExecRetrieve(TupleTableSlot *slot, void (*printfunc) (),
EState *estate);
static void
ExecAppend(TupleTableSlot * slot, ItemPointer tupleid,
EState * estate);
ExecAppend(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate);
static void
ExecDelete(TupleTableSlot * slot, ItemPointer tupleid,
EState * estate);
ExecDelete(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate);
static void
ExecReplace(TupleTableSlot * slot, ItemPointer tupleid,
EState * estate, Query * parseTree);
ExecReplace(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate, Query *parseTree);
/* end of local decls */
@ -110,7 +110,7 @@ ExecutorLimit(int limit)
* ----------------------------------------------------------------
*/
TupleDesc
ExecutorStart(QueryDesc * queryDesc, EState * estate)
ExecutorStart(QueryDesc *queryDesc, EState *estate)
{
TupleDesc result;
@ -155,7 +155,7 @@ ExecutorStart(QueryDesc * queryDesc, EState * estate)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecutorRun(QueryDesc * queryDesc, EState * estate, int feature, int count)
ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count)
{
CmdType operation;
Query *parseTree;
@ -279,7 +279,7 @@ ExecutorRun(QueryDesc * queryDesc, EState * estate, int feature, int count)
* ----------------------------------------------------------------
*/
void
ExecutorEnd(QueryDesc * queryDesc, EState * estate)
ExecutorEnd(QueryDesc *queryDesc, EState *estate)
{
/* sanity checks */
Assert(queryDesc != NULL);
@ -300,8 +300,8 @@ ExecutorEnd(QueryDesc * queryDesc, EState * estate)
static void
ExecCheckPerms(CmdType operation,
int resultRelation,
List * rangeTable,
Query * parseTree)
List *rangeTable,
Query *parseTree)
{
int i = 1;
Oid relid;
@ -390,7 +390,7 @@ ExecCheckPerms(CmdType operation,
* ----------------------------------------------------------------
*/
static TupleDesc
InitPlan(CmdType operation, Query * parseTree, Plan * plan, EState * estate)
InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
{
List *rangeTable;
int resultRelation;
@ -625,7 +625,7 @@ InitPlan(CmdType operation, Query * parseTree, Plan * plan, EState * estate)
* ----------------------------------------------------------------
*/
static void
EndPlan(Plan * plan, EState * estate)
EndPlan(Plan *plan, EState *estate)
{
RelationInfo *resultRelationInfo;
Relation intoRelationDesc;
@ -699,9 +699,9 @@ EndPlan(Plan * plan, EState * estate)
user can see it*/
static TupleTableSlot *
ExecutePlan(EState * estate,
Plan * plan,
Query * parseTree,
ExecutePlan(EState *estate,
Plan *plan,
Query *parseTree,
CmdType operation,
int numberTuples,
ScanDirection direction,
@ -898,9 +898,9 @@ ExecutePlan(EState * estate,
* ----------------------------------------------------------------
*/
static void
ExecRetrieve(TupleTableSlot * slot,
ExecRetrieve(TupleTableSlot *slot,
void (*printfunc) (),
EState * estate)
EState *estate)
{
HeapTuple tuple;
TupleDesc attrtype;
@ -941,9 +941,9 @@ ExecRetrieve(TupleTableSlot * slot,
*/
static void
ExecAppend(TupleTableSlot * slot,
ExecAppend(TupleTableSlot *slot,
ItemPointer tupleid,
EState * estate)
EState *estate)
{
HeapTuple tuple;
RelationInfo *resultRelationInfo;
@ -1046,9 +1046,9 @@ ExecAppend(TupleTableSlot * slot,
* ----------------------------------------------------------------
*/
static void
ExecDelete(TupleTableSlot * slot,
ExecDelete(TupleTableSlot *slot,
ItemPointer tupleid,
EState * estate)
EState *estate)
{
RelationInfo *resultRelationInfo;
Relation resultRelationDesc;
@ -1114,10 +1114,10 @@ ExecDelete(TupleTableSlot * slot,
* ----------------------------------------------------------------
*/
static void
ExecReplace(TupleTableSlot * slot,
ExecReplace(TupleTableSlot *slot,
ItemPointer tupleid,
EState * estate,
Query * parseTree)
EState *estate,
Query *parseTree)
{
HeapTuple tuple;
RelationInfo *resultRelationInfo;

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

@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.4 1997/09/08 02:22:30 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.5 1997/09/08 21:42:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -103,7 +103,7 @@
* ------------------------------------------------------------------------
*/
bool
ExecInitNode(Plan * node, EState * estate, Plan * parent)
ExecInitNode(Plan *node, EState *estate, Plan *parent)
{
bool result;
@ -207,7 +207,7 @@ ExecInitNode(Plan * node, EState * estate, Plan * parent)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecProcNode(Plan * node, Plan * parent)
ExecProcNode(Plan *node, Plan *parent)
{
TupleTableSlot *result;
@ -302,7 +302,7 @@ ExecProcNode(Plan * node, Plan * parent)
}
int
ExecCountSlotsNode(Plan * node)
ExecCountSlotsNode(Plan *node)
{
if (node == (Plan *) NULL)
return 0;
@ -387,7 +387,7 @@ ExecCountSlotsNode(Plan * node)
* ----------------------------------------------------------------
*/
void
ExecEndNode(Plan * node, Plan * parent)
ExecEndNode(Plan *node, Plan *parent)
{
/* ----------------
* do nothing when we get to the end

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.15 1997/09/08 20:55:37 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.16 1997/09/08 21:43:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -69,27 +69,27 @@ bool execConstByVal;
int execConstLen;
/* static functions decls */
static Datum ExecEvalAggreg(Aggreg *agg, ExprContext * econtext, bool * isNull);
static Datum ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull);
static Datum
ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext * econtext,
bool * isNull, bool * isDone);
static Datum ExecEvalAnd(Expr * andExpr, ExprContext * econtext, bool * isNull);
ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext *econtext,
bool *isNull, bool *isDone);
static Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull);
static Datum
ExecEvalFunc(Expr * funcClause, ExprContext * econtext,
bool * isNull, bool * isDone);
ExecEvalFunc(Expr *funcClause, ExprContext *econtext,
bool *isNull, bool *isDone);
static void
ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext * econtext,
List * argList, Datum argV[], bool * argIsDone);
static Datum ExecEvalNot(Expr * notclause, ExprContext * econtext, bool * isNull);
ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext *econtext,
List *argList, Datum argV[], bool *argIsDone);
static Datum ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull);
static Datum
ExecEvalOper(Expr * opClause, ExprContext * econtext,
bool * isNull);
static Datum ExecEvalOr(Expr * orExpr, ExprContext * econtext, bool * isNull);
static Datum ExecEvalVar(Var * variable, ExprContext * econtext, bool * isNull);
ExecEvalOper(Expr *opClause, ExprContext *econtext,
bool *isNull);
static Datum ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull);
static Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
static Datum
ExecMakeFunctionResult(Node * node, List * arguments,
ExprContext * econtext, bool * isNull, bool * isDone);
static bool ExecQualClause(Node * clause, ExprContext * econtext);
ExecMakeFunctionResult(Node *node, List *arguments,
ExprContext *econtext, bool *isNull, bool *isDone);
static bool ExecQualClause(Node *clause, ExprContext *econtext);
/* --------------------------------
* ExecEvalArrayRef
@ -102,9 +102,9 @@ static bool ExecQualClause(Node * clause, ExprContext * econtext);
*/
static Datum
ExecEvalArrayRef(ArrayRef *arrayRef,
ExprContext * econtext,
bool * isNull,
bool * isDone)
ExprContext *econtext,
bool *isNull,
bool *isDone)
{
bool dummy;
int i = 0,
@ -200,7 +200,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalAggreg(Aggreg *agg, ExprContext * econtext, bool * isNull)
ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull)
{
*isNull = econtext->ecxt_nulls[agg->aggno];
@ -231,7 +231,7 @@ ExecEvalAggreg(Aggreg *agg, ExprContext * econtext, bool * isNull)
*
* ---------------------------------------------------------------- */
static Datum
ExecEvalVar(Var * variable, ExprContext * econtext, bool * isNull)
ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
{
Datum result;
TupleTableSlot *slot;
@ -377,7 +377,7 @@ ExecEvalVar(Var * variable, ExprContext * econtext, bool * isNull)
* ----------------------------------------------------------------
*/
Datum
ExecEvalParam(Param * expression, ExprContext * econtext, bool * isNull)
ExecEvalParam(Param *expression, ExprContext *econtext, bool *isNull)
{
char *thisParameterName;
@ -509,9 +509,9 @@ ExecEvalParam(Param * expression, ExprContext * econtext, bool * isNull)
*/
#ifdef NOT_USED
static char *
GetAttributeByNum(TupleTableSlot * slot,
GetAttributeByNum(TupleTableSlot *slot,
AttrNumber attrno,
bool * isNull)
bool *isNull)
{
Datum retval;
@ -546,9 +546,9 @@ GetAttributeByNum(TupleTableSlot * slot,
/* XXX char16 name for catalogs */
#ifdef NOT_USED
char *
att_by_num(TupleTableSlot * slot,
att_by_num(TupleTableSlot *slot,
AttrNumber attrno,
bool * isNull)
bool *isNull)
{
return (GetAttributeByNum(slot, attrno, isNull));
}
@ -556,7 +556,7 @@ att_by_num(TupleTableSlot * slot,
#endif
char *
GetAttributeByName(TupleTableSlot * slot, char *attname, bool * isNull)
GetAttributeByName(TupleTableSlot *slot, char *attname, bool *isNull)
{
AttrNumber attrno;
TupleDesc tupdesc;
@ -609,7 +609,7 @@ GetAttributeByName(TupleTableSlot * slot, char *attname, bool * isNull)
/* XXX char16 name for catalogs */
#ifdef NOT_USED
char *
att_by_name(TupleTableSlot * slot, char *attname, bool * isNull)
att_by_name(TupleTableSlot *slot, char *attname, bool *isNull)
{
return (GetAttributeByName(slot, attname, isNull));
}
@ -618,10 +618,10 @@ att_by_name(TupleTableSlot * slot, char *attname, bool * isNull)
static void
ExecEvalFuncArgs(FunctionCachePtr fcache,
ExprContext * econtext,
List * argList,
ExprContext *econtext,
List *argList,
Datum argV[],
bool * argIsDone)
bool *argIsDone)
{
int i;
bool argIsNull,
@ -664,11 +664,11 @@ ExecEvalFuncArgs(FunctionCachePtr fcache,
* ----------------
*/
static Datum
ExecMakeFunctionResult(Node * node,
List * arguments,
ExprContext * econtext,
bool * isNull,
bool * isDone)
ExecMakeFunctionResult(Node *node,
List *arguments,
ExprContext *econtext,
bool *isNull,
bool *isDone)
{
Datum argv[MAXFMGRARGS];
FunctionCachePtr fcache;
@ -864,7 +864,7 @@ ExecMakeFunctionResult(Node * node,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalOper(Expr * opClause, ExprContext * econtext, bool * isNull)
ExecEvalOper(Expr *opClause, ExprContext *econtext, bool *isNull)
{
Oper *op;
List *argList;
@ -909,10 +909,10 @@ ExecEvalOper(Expr * opClause, ExprContext * econtext, bool * isNull)
*/
static Datum
ExecEvalFunc(Expr * funcClause,
ExprContext * econtext,
bool * isNull,
bool * isDone)
ExecEvalFunc(Expr *funcClause,
ExprContext *econtext,
bool *isNull,
bool *isDone)
{
Func *func;
List *argList;
@ -964,7 +964,7 @@ ExecEvalFunc(Expr * funcClause,
* ----------------------------------------------------------------
*/
static Datum
ExecEvalNot(Expr * notclause, ExprContext * econtext, bool * isNull)
ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull)
{
Datum expr_value;
Node *clause;
@ -1003,7 +1003,7 @@ ExecEvalNot(Expr * notclause, ExprContext * econtext, bool * isNull)
* ----------------------------------------------------------------
*/
static Datum
ExecEvalOr(Expr * orExpr, ExprContext * econtext, bool * isNull)
ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
List *clause;
@ -1067,7 +1067,7 @@ ExecEvalOr(Expr * orExpr, ExprContext * econtext, bool * isNull)
* ----------------------------------------------------------------
*/
static Datum
ExecEvalAnd(Expr * andExpr, ExprContext * econtext, bool * isNull)
ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
List *clause;
@ -1144,10 +1144,10 @@ ExecEvalAnd(Expr * andExpr, ExprContext * econtext, bool * isNull)
* ----------------------------------------------------------------
*/
Datum
ExecEvalExpr(Node * expression,
ExprContext * econtext,
bool * isNull,
bool * isDone)
ExecEvalExpr(Node *expression,
ExprContext *econtext,
bool *isNull,
bool *isDone)
{
Datum retDatum = 0;
@ -1257,7 +1257,7 @@ ExecEvalExpr(Node * expression,
* ----------------------------------------------------------------
*/
static bool
ExecQualClause(Node * clause, ExprContext * econtext)
ExecQualClause(Node *clause, ExprContext *econtext)
{
Datum expr_value;
bool isNull;
@ -1302,7 +1302,7 @@ ExecQualClause(Node * clause, ExprContext * econtext)
* ----------------------------------------------------------------
*/
bool
ExecQual(List * qual, ExprContext * econtext)
ExecQual(List *qual, ExprContext *econtext)
{
List *clause;
bool result;
@ -1354,7 +1354,7 @@ ExecQual(List * qual, ExprContext * econtext)
}
int
ExecTargetListLength(List * targetlist)
ExecTargetListLength(List *targetlist)
{
int len;
List *tl;
@ -1381,12 +1381,12 @@ ExecTargetListLength(List * targetlist)
* ----------------------------------------------------------------
*/
static HeapTuple
ExecTargetList(List * targetlist,
ExecTargetList(List *targetlist,
int nodomains,
TupleDesc targettype,
Datum * values,
ExprContext * econtext,
bool * isDone)
Datum *values,
ExprContext *econtext,
bool *isDone)
{
char nulls_array[64];
bool fjNullArray[64];
@ -1579,7 +1579,7 @@ ExecTargetList(List * targetlist,
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecProject(ProjectionInfo * projInfo, bool * isDone)
ExecProject(ProjectionInfo *projInfo, bool *isDone)
{
TupleTableSlot *slot;
List *targetlist;

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

@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.5 1997/09/08 02:22:34 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.6 1997/09/08 21:43:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -43,8 +43,8 @@
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecScan(Scan * node,
TupleTableSlot * (*accessMtd) ()) /* function returning a
ExecScan(Scan *node,
TupleTableSlot *(*accessMtd) ()) /* function returning a
* tuple */
{
CommonScanState *scanstate;

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

@ -14,7 +14,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.8 1997/09/08 02:22:35 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.9 1997/09/08 21:43:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -131,7 +131,7 @@
#include "parser/catalog_utils.h"
#include "catalog/pg_type.h"
static TupleTableSlot *NodeGetResultTupleSlot(Plan * node);
static TupleTableSlot *NodeGetResultTupleSlot(Plan *node);
/* ----------------------------------------------------------------
@ -150,8 +150,8 @@ static TupleTableSlot *NodeGetResultTupleSlot(Plan * node);
* --------------------------------
*/
TupleTable /* return: address of table */
ExecCreateTupleTable(int initialSize) /* initial number of slots
* in table */
ExecCreateTupleTable(int initialSize) /* initial number of slots in
* table */
{
TupleTable newtable; /* newly allocated table */
TupleTableSlot *array; /* newly allocated slot array */
@ -349,7 +349,7 @@ ExecAllocTableSlot(TupleTable table)
*/
TupleTableSlot * /* return: slot passed */
ExecStoreTuple(HeapTuple tuple, /* tuple to store */
TupleTableSlot * slot, /* slot in which to store tuple */
TupleTableSlot *slot, /* slot in which to store tuple */
Buffer buffer, /* buffer associated with tuple */
bool shouldFree) /* true if we call pfree() when we gc. */
{
@ -381,7 +381,7 @@ ExecStoreTuple(HeapTuple tuple, /* tuple to store */
* --------------------------------
*/
TupleTableSlot * /* return: slot passed */
ExecClearTuple(TupleTableSlot * slot) /* slot in which to store tuple */
ExecClearTuple(TupleTableSlot *slot) /* slot in which to store tuple */
{
HeapTuple oldtuple; /* prior contents of slot */
@ -441,7 +441,7 @@ ExecClearTuple(TupleTableSlot * slot) /* slot in which to store tuple */
*/
#ifdef NOT_USED
bool /* return: slot policy */
ExecSlotPolicy(TupleTableSlot * slot) /* slot to inspect */
ExecSlotPolicy(TupleTableSlot *slot) /* slot to inspect */
{
return slot->ttc_shouldFree;
}
@ -458,7 +458,7 @@ ExecSlotPolicy(TupleTableSlot * slot) /* slot to inspect */
* --------------------------------
*/
bool /* return: old slot policy */
ExecSetSlotPolicy(TupleTableSlot * slot, /* slot to change */
ExecSetSlotPolicy(TupleTableSlot *slot, /* slot to change */
bool shouldFree) /* true if we call pfree() when we
* gc. */
{
@ -487,7 +487,7 @@ ExecSetSlotPolicy(TupleTableSlot * slot, /* slot to change */
* --------------------------------
*/
TupleDesc /* return: old slot tuple descriptor */
ExecSetSlotDescriptor(TupleTableSlot * slot, /* slot to change */
ExecSetSlotDescriptor(TupleTableSlot *slot, /* slot to change */
TupleDesc tupdesc) /* tuple descriptor */
{
TupleDesc old_tupdesc = slot->ttc_tupleDescriptor;
@ -503,7 +503,7 @@ ExecSetSlotDescriptor(TupleTableSlot * slot, /* slot to change */
* --------------------------------
*/
void
ExecSetSlotDescriptorIsNew(TupleTableSlot * slot, /* slot to change */
ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, /* slot to change */
bool isNew) /* "isNew" setting */
{
slot->ttc_descIsNew = isNew;
@ -518,7 +518,7 @@ ExecSetSlotDescriptorIsNew(TupleTableSlot * slot, /* slot to change */
*/
#ifdef NOT_USED
TupleDesc /* return: old slot tuple descriptor */
ExecSetNewSlotDescriptor(TupleTableSlot * slot, /* slot to change */
ExecSetNewSlotDescriptor(TupleTableSlot *slot, /* slot to change */
TupleDesc tupdesc) /* tuple descriptor */
{
TupleDesc old_tupdesc = slot->ttc_tupleDescriptor;
@ -554,7 +554,7 @@ ExecSetNewSlotDescriptor(TupleTableSlot * slot, /* slot to change */
*/
#ifdef NOT_USED
Buffer /* return: old slot buffer */
ExecSetSlotBuffer(TupleTableSlot * slot, /* slot to change */
ExecSetSlotBuffer(TupleTableSlot *slot, /* slot to change */
Buffer b) /* tuple descriptor */
{
Buffer oldb = slot->ttc_buffer;
@ -575,7 +575,7 @@ ExecSetSlotBuffer(TupleTableSlot * slot, /* slot to change */
* --------------------------------
*/
void
ExecIncrSlotBufferRefcnt(TupleTableSlot * slot) /* slot to bump refcnt */
ExecIncrSlotBufferRefcnt(TupleTableSlot *slot) /* slot to bump refcnt */
{
/* Buffer b = SlotBuffer((TupleTableSlot*) slot); */
Buffer b = slot->ttc_buffer;
@ -597,7 +597,7 @@ ExecIncrSlotBufferRefcnt(TupleTableSlot * slot) /* slot to bump refcnt */
* ----------------
*/
bool /* return: true if tuple in slot is NULL */
TupIsNull(TupleTableSlot * slot) /* slot to check */
TupIsNull(TupleTableSlot *slot) /* slot to check */
{
HeapTuple tuple; /* contents of slot (returned) */
@ -629,7 +629,7 @@ TupIsNull(TupleTableSlot * slot) /* slot to check */
*/
#ifdef NOT_USED
bool /* return: descriptor "is new" */
ExecSlotDescriptorIsNew(TupleTableSlot * slot) /* slot to inspect */
ExecSlotDescriptorIsNew(TupleTableSlot *slot) /* slot to inspect */
{
/* bool isNew = SlotTupleDescriptorIsNew((TupleTableSlot*) slot);
return isNew; */
@ -667,7 +667,7 @@ ExecSlotDescriptorIsNew(TupleTableSlot * slot) /* slot to inspect */
* ----------------
*/
void
ExecInitResultTupleSlot(EState * estate, CommonState * commonstate)
ExecInitResultTupleSlot(EState *estate, CommonState *commonstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
@ -679,7 +679,7 @@ ExecInitResultTupleSlot(EState * estate, CommonState * commonstate)
* ----------------
*/
void
ExecInitScanTupleSlot(EState * estate, CommonScanState * commonscanstate)
ExecInitScanTupleSlot(EState *estate, CommonScanState *commonscanstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
@ -691,7 +691,7 @@ ExecInitScanTupleSlot(EState * estate, CommonScanState * commonscanstate)
* ----------------
*/
void
ExecInitMarkedTupleSlot(EState * estate, MergeJoinState * mergestate)
ExecInitMarkedTupleSlot(EState *estate, MergeJoinState *mergestate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
@ -703,7 +703,7 @@ ExecInitMarkedTupleSlot(EState * estate, MergeJoinState * mergestate)
* ----------------
*/
void
ExecInitOuterTupleSlot(EState * estate, HashJoinState * hashstate)
ExecInitOuterTupleSlot(EState *estate, HashJoinState *hashstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
@ -716,7 +716,7 @@ ExecInitOuterTupleSlot(EState * estate, HashJoinState * hashstate)
*/
#ifdef NOT_USED
void
ExecInitHashTupleSlot(EState * estate, HashJoinState * hashstate)
ExecInitHashTupleSlot(EState *estate, HashJoinState *hashstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
@ -726,7 +726,7 @@ ExecInitHashTupleSlot(EState * estate, HashJoinState * hashstate)
#endif
static TupleTableSlot *
NodeGetResultTupleSlot(Plan * node)
NodeGetResultTupleSlot(Plan *node)
{
TupleTableSlot *slot;
@ -894,7 +894,7 @@ NodeGetResultTupleSlot(Plan * node)
*/
TupleDesc
ExecGetTupType(Plan * node)
ExecGetTupType(Plan *node)
{
TupleTableSlot *slot;
TupleDesc tupType;
@ -946,7 +946,7 @@ ExecCopyTupType(TupleDesc td, int natts)
* ----------------------------------------------------------------
*/
TupleDesc
ExecTypeFromTL(List * targetList)
ExecTypeFromTL(List *targetList)
{
List *tlcdr;
TupleDesc typeInfo;

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.17 1997/09/08 20:55:39 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.18 1997/09/08 21:43:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -106,7 +106,7 @@ ResetTupleCount(void)
*/
#ifdef NOT_USED
void
DisplayTupleCount(FILE * statfp)
DisplayTupleCount(FILE *statfp)
{
if (NTupleProcessed > 0)
fprintf(statfp, "!\t%d tuple%s processed, ", NTupleProcessed,
@ -157,7 +157,7 @@ DisplayTupleCount(FILE * statfp)
* ----------------
*/
void
ExecAssignNodeBaseInfo(EState * estate, CommonState * cstate, Plan * parent)
ExecAssignNodeBaseInfo(EState *estate, CommonState *cstate, Plan *parent)
{
int baseId;
@ -176,7 +176,7 @@ ExecAssignNodeBaseInfo(EState * estate, CommonState * cstate, Plan * parent)
* ----------------
*/
void
ExecAssignExprContext(EState * estate, CommonState * commonstate)
ExecAssignExprContext(EState *estate, CommonState *commonstate)
{
ExprContext *econtext;
ParamListInfo paraminfo;
@ -207,7 +207,7 @@ ExecAssignExprContext(EState * estate, CommonState * commonstate)
* ----------------
*/
void
ExecAssignResultType(CommonState * commonstate,
ExecAssignResultType(CommonState *commonstate,
TupleDesc tupDesc)
{
TupleTableSlot *slot;
@ -221,7 +221,7 @@ ExecAssignResultType(CommonState * commonstate,
* ----------------
*/
void
ExecAssignResultTypeFromOuterPlan(Plan * node, CommonState * commonstate)
ExecAssignResultTypeFromOuterPlan(Plan *node, CommonState *commonstate)
{
Plan *outerPlan;
TupleDesc tupDesc;
@ -237,7 +237,7 @@ ExecAssignResultTypeFromOuterPlan(Plan * node, CommonState * commonstate)
* ----------------
*/
void
ExecAssignResultTypeFromTL(Plan * node, CommonState * commonstate)
ExecAssignResultTypeFromTL(Plan *node, CommonState *commonstate)
{
List *targetList;
int i;
@ -293,7 +293,7 @@ ExecAssignResultTypeFromTL(Plan * node, CommonState * commonstate)
* ----------------
*/
TupleDesc
ExecGetResultType(CommonState * commonstate)
ExecGetResultType(CommonState *commonstate)
{
TupleTableSlot *slot = commonstate->cs_ResultTupleSlot;
@ -306,7 +306,7 @@ ExecGetResultType(CommonState * commonstate)
*/
#ifdef NOT_USED
void
ExecFreeResultType(CommonState * commonstate)
ExecFreeResultType(CommonState *commonstate)
{
TupleTableSlot *slot;
TupleDesc tupType;
@ -326,7 +326,7 @@ ExecFreeResultType(CommonState * commonstate)
* ----------------
*/
void
ExecAssignProjectionInfo(Plan * node, CommonState * commonstate)
ExecAssignProjectionInfo(Plan *node, CommonState *commonstate)
{
ProjectionInfo *projInfo;
List *targetList;
@ -352,7 +352,7 @@ ExecAssignProjectionInfo(Plan * node, CommonState * commonstate)
* ----------------
*/
void
ExecFreeProjectionInfo(CommonState * commonstate)
ExecFreeProjectionInfo(CommonState *commonstate)
{
ProjectionInfo *projInfo;
@ -391,7 +391,7 @@ ExecFreeProjectionInfo(CommonState * commonstate)
* ----------------
*/
TupleDesc
ExecGetScanType(CommonScanState * csstate)
ExecGetScanType(CommonScanState *csstate)
{
TupleTableSlot *slot = csstate->css_ScanTupleSlot;
@ -404,7 +404,7 @@ ExecGetScanType(CommonScanState * csstate)
*/
#ifdef NOT_USED
void
ExecFreeScanType(CommonScanState * csstate)
ExecFreeScanType(CommonScanState *csstate)
{
TupleTableSlot *slot;
TupleDesc tupType;
@ -423,7 +423,7 @@ ExecFreeScanType(CommonScanState * csstate)
* ----------------
*/
void
ExecAssignScanType(CommonScanState * csstate,
ExecAssignScanType(CommonScanState *csstate,
TupleDesc tupDesc)
{
TupleTableSlot *slot;
@ -437,7 +437,7 @@ ExecAssignScanType(CommonScanState * csstate,
* ----------------
*/
void
ExecAssignScanTypeFromOuterPlan(Plan * node, CommonScanState * csstate)
ExecAssignScanTypeFromOuterPlan(Plan *node, CommonScanState *csstate)
{
Plan *outerPlan;
TupleDesc tupDesc;
@ -569,7 +569,7 @@ ExecFreeTypeInfo(TupleDesc typeInfo)
* ----------------------------------------------------------------
*/
TupleDesc
QueryDescGetTypeInfo(QueryDesc * queryDesc)
QueryDescGetTypeInfo(QueryDesc *queryDesc)
{
Plan *plan;
TupleDesc tupleType;
@ -706,7 +706,7 @@ ExecGetIndexKeyInfo(IndexTupleForm indexTuple,
*/
void
ExecOpenIndices(Oid resultRelationOid,
RelationInfo * resultRelationInfo)
RelationInfo *resultRelationInfo)
{
Relation indexRd;
HeapScanDesc indexSd;
@ -952,7 +952,7 @@ ExecOpenIndices(Oid resultRelationOid,
* ----------------------------------------------------------------
*/
void
ExecCloseIndices(RelationInfo * resultRelationInfo)
ExecCloseIndices(RelationInfo *resultRelationInfo)
{
int i;
int numIndices;
@ -984,7 +984,7 @@ IndexTuple
ExecFormIndexTuple(HeapTuple heapTuple,
Relation heapRelation,
Relation indexRelation,
IndexInfo * indexInfo)
IndexInfo *indexInfo)
{
IndexTuple indexTuple;
TupleDesc heapDescriptor;
@ -1070,9 +1070,9 @@ ExecFormIndexTuple(HeapTuple heapTuple,
* ----------------------------------------------------------------
*/
void
ExecInsertIndexTuples(TupleTableSlot * slot,
ExecInsertIndexTuples(TupleTableSlot *slot,
ItemPointer tupleid,
EState * estate,
EState *estate,
bool is_update)
{
HeapTuple heapTuple;
@ -1186,8 +1186,8 @@ ExecInsertIndexTuples(TupleTableSlot * slot,
* ----------------------------------------------------------------
*/
void
setVarAttrLenForCreateTable(TupleDesc tupType, List * targetList,
List * rangeTable)
setVarAttrLenForCreateTable(TupleDesc tupType, List *targetList,
List *rangeTable)
{
List *tl;
TargetEntry *tle;

44
src/backend/executor/functions.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.9 1997/09/08 02:22:37 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.10 1997/09/08 21:43:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -44,7 +44,7 @@
typedef enum
{
F_EXEC_START, F_EXEC_RUN, F_EXEC_DONE
} ExecStatus;
} ExecStatus;
typedef struct local_es
{
@ -52,30 +52,30 @@ typedef struct local_es
EState *estate;
struct local_es *next;
ExecStatus status;
} execution_state;
} execution_state;
#define LAST_POSTQUEL_COMMAND(es) ((es)->next == (execution_state *)NULL)
/* non-export function prototypes */
static TupleDesc postquel_start(execution_state * es);
static TupleDesc postquel_start(execution_state *es);
static execution_state *
init_execution_state(FunctionCachePtr fcache,
char *args[]);
static TupleTableSlot *postquel_getnext(execution_state * es);
static void postquel_end(execution_state * es);
static TupleTableSlot *postquel_getnext(execution_state *es);
static void postquel_end(execution_state *es);
static void
postquel_sub_params(execution_state * es, int nargs,
char *args[], bool * nullV);
postquel_sub_params(execution_state *es, int nargs,
char *args[], bool *nullV);
static Datum
postquel_execute(execution_state * es, FunctionCachePtr fcache,
List * fTlist, char **args, bool * isNull);
postquel_execute(execution_state *es, FunctionCachePtr fcache,
List *fTlist, char **args, bool *isNull);
Datum
ProjectAttribute(TupleDesc TD,
TargetEntry * tlist,
TargetEntry *tlist,
HeapTuple tup,
bool * isnullP)
bool *isnullP)
{
Datum val,
valueP;
@ -172,7 +172,7 @@ init_execution_state(FunctionCachePtr fcache,
}
static TupleDesc
postquel_start(execution_state * es)
postquel_start(execution_state *es)
{
#ifdef FUNC_UTIL_PATCH
@ -189,7 +189,7 @@ postquel_start(execution_state * es)
}
static TupleTableSlot *
postquel_getnext(execution_state * es)
postquel_getnext(execution_state *es)
{
int feature;
@ -214,7 +214,7 @@ postquel_getnext(execution_state * es)
}
static void
postquel_end(execution_state * es)
postquel_end(execution_state *es)
{
#ifdef FUNC_UTIL_PATCH
@ -231,10 +231,10 @@ postquel_end(execution_state * es)
}
static void
postquel_sub_params(execution_state * es,
postquel_sub_params(execution_state *es,
int nargs,
char *args[],
bool * nullV)
bool *nullV)
{
ParamListInfo paramLI;
EState *estate;
@ -256,7 +256,7 @@ postquel_sub_params(execution_state * es,
static TupleTableSlot *
copy_function_result(FunctionCachePtr fcache,
TupleTableSlot * resultSlot)
TupleTableSlot *resultSlot)
{
TupleTableSlot *funcSlot;
TupleDesc resultTd;
@ -299,11 +299,11 @@ copy_function_result(FunctionCachePtr fcache,
}
static Datum
postquel_execute(execution_state * es,
postquel_execute(execution_state *es,
FunctionCachePtr fcache,
List * fTlist,
List *fTlist,
char **args,
bool * isNull)
bool *isNull)
{
TupleTableSlot *slot;
Datum value;
@ -398,7 +398,7 @@ postquel_execute(execution_state * es,
}
Datum
postquel_function(Func * funcNode, char **args, bool * isNull, bool * isDone)
postquel_function(Func *funcNode, char **args, bool *isNull, bool *isDone)
{
execution_state *es;
Datum result = 0;

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

@ -47,7 +47,7 @@ typedef struct AggFuncInfo
int finalfn_nargs;
} AggFuncInfo;
static Datum aggGetAttr(TupleTableSlot * tuple, Aggreg *agg, bool * isNull);
static Datum aggGetAttr(TupleTableSlot *tuple, Aggreg *agg, bool *isNull);
/* ---------------------------------------
@ -376,7 +376,7 @@ ExecAgg(Agg *node)
value2[i] =
(Datum) fmgr_c(aggfns->xfn2, aggfns->xfn2_oid,
aggfns->xfn2_nargs,
(FmgrValues *) & xfn2_val, &isNull2);
(FmgrValues *) &xfn2_val, &isNull2);
Assert(!isNull2);
}
}
@ -488,7 +488,7 @@ ExecAgg(Agg *node)
* -----------------
*/
bool
ExecInitAgg(Agg *node, EState * estate, Plan * parent)
ExecInitAgg(Agg *node, EState *estate, Plan *parent)
{
AggState *aggstate;
Plan *outerPlan;
@ -591,9 +591,9 @@ ExecEndAgg(Agg *node)
* over from the tuple
*/
static Datum
aggGetAttr(TupleTableSlot * slot,
aggGetAttr(TupleTableSlot *slot,
Aggreg *agg,
bool * isNull)
bool *isNull)
{
Datum result;
AttrNumber attnum;

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.8 1997/09/08 20:55:41 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.9 1997/09/08 21:43:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -182,7 +182,7 @@ exec_append_initialize_next(Append *node)
* ----------------------------------------------------------------
*/
bool
ExecInitAppend(Append *node, EState * estate, Plan * parent)
ExecInitAppend(Append *node, EState *estate, Plan *parent)
{
AppendState *unionstate;
int nplans;

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

@ -13,7 +13,7 @@
* columns. (ie. tuples from the same group are consecutive)
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.8 1997/09/08 20:55:43 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.9 1997/09/08 21:43:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -28,10 +28,10 @@
#include "executor/executor.h"
#include "executor/nodeGroup.h"
static TupleTableSlot *ExecGroupEveryTuple(Group * node);
static TupleTableSlot *ExecGroupOneTuple(Group * node);
static TupleTableSlot *ExecGroupEveryTuple(Group *node);
static TupleTableSlot *ExecGroupOneTuple(Group *node);
static bool
sameGroup(TupleTableSlot * oldslot, TupleTableSlot * newslot,
sameGroup(TupleTableSlot *oldslot, TupleTableSlot *newslot,
int numCols, AttrNumber *grpColIdx, TupleDesc tupdesc);
/* ---------------------------------------
@ -51,7 +51,7 @@ sameGroup(TupleTableSlot * oldslot, TupleTableSlot * newslot,
* ------------------------------------------
*/
TupleTableSlot *
ExecGroup(Group * node)
ExecGroup(Group *node)
{
if (node->tuplePerGroup)
return ExecGroupEveryTuple(node);
@ -64,7 +64,7 @@ ExecGroup(Group * node)
* return every tuple with a NULL between each group
*/
static TupleTableSlot *
ExecGroupEveryTuple(Group * node)
ExecGroupEveryTuple(Group *node)
{
GroupState *grpstate;
EState *estate;
@ -165,7 +165,7 @@ ExecGroupEveryTuple(Group * node)
* tuples.
*/
static TupleTableSlot *
ExecGroupOneTuple(Group * node)
ExecGroupOneTuple(Group *node)
{
GroupState *grpstate;
EState *estate;
@ -289,7 +289,7 @@ ExecGroupOneTuple(Group * node)
* -----------------
*/
bool
ExecInitGroup(Group * node, EState * estate, Plan * parent)
ExecInitGroup(Group *node, EState *estate, Plan *parent)
{
GroupState *grpstate;
Plan *outerPlan;
@ -345,7 +345,7 @@ ExecInitGroup(Group * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsGroup(Group * node)
ExecCountSlotsGroup(Group *node)
{
return ExecCountSlotsNode(outerPlan(node)) + GROUP_NSLOTS;
}
@ -356,7 +356,7 @@ ExecCountSlotsGroup(Group * node)
* -----------------------
*/
void
ExecEndGroup(Group * node)
ExecEndGroup(Group *node)
{
GroupState *grpstate;
Plan *outerPlan;
@ -380,8 +380,8 @@ ExecEndGroup(Group * node)
* code swiped from nodeUnique.c
*/
static bool
sameGroup(TupleTableSlot * oldslot,
TupleTableSlot * newslot,
sameGroup(TupleTableSlot *oldslot,
TupleTableSlot *newslot,
int numCols,
AttrNumber *grpColIdx,
TupleDesc tupdesc)

32
src/backend/executor/nodeHash.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.12 1997/09/08 02:22:42 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.13 1997/09/08 21:43:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -47,7 +47,7 @@ static int HashTBSize;
static void mk_hj_temp(char *tempname);
static int hashFunc(char *key, int len);
static int ExecHashPartition(Hash * node);
static int ExecHashPartition(Hash *node);
static RelativeAddr hashTableAlloc(int size, HashJoinTable hashtable);
static void
ExecHashOverflowInsert(HashJoinTable hashtable,
@ -62,7 +62,7 @@ ExecHashOverflowInsert(HashJoinTable hashtable,
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecHash(Hash * node)
ExecHash(Hash *node)
{
EState *estate;
HashState *hashstate;
@ -165,7 +165,7 @@ ExecHash(Hash * node)
* ----------------------------------------------------------------
*/
bool
ExecInitHash(Hash * node, EState * estate, Plan * parent)
ExecInitHash(Hash *node, EState *estate, Plan *parent)
{
HashState *hashstate;
Plan *outerPlan;
@ -224,7 +224,7 @@ ExecInitHash(Hash * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsHash(Hash * node)
ExecCountSlotsHash(Hash *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
@ -238,7 +238,7 @@ ExecCountSlotsHash(Hash * node)
* ----------------------------------------------------------------
*/
void
ExecEndHash(Hash * node)
ExecEndHash(Hash *node)
{
HashState *hashstate;
Plan *outerPlan;
@ -288,7 +288,7 @@ hashTableAlloc(int size, HashJoinTable hashtable)
#define FUDGE_FAC 1.5
HashJoinTable
ExecHashTableCreate(Hash * node)
ExecHashTableCreate(Hash *node)
{
Plan *outerNode;
int nbatch;
@ -456,9 +456,9 @@ ExecHashTableCreate(Hash * node)
*/
void
ExecHashTableInsert(HashJoinTable hashtable,
ExprContext * econtext,
Var * hashkey,
File * batches)
ExprContext *econtext,
Var *hashkey,
File *batches)
{
TupleTableSlot *slot;
HeapTuple heapTuple;
@ -548,8 +548,8 @@ ExecHashTableDestroy(HashJoinTable hashtable)
*/
int
ExecHashGetBucket(HashJoinTable hashtable,
ExprContext * econtext,
Var * hashkey)
ExprContext *econtext,
Var *hashkey)
{
int bucketno;
Datum keyval;
@ -681,11 +681,11 @@ ExecHashOverflowInsert(HashJoinTable hashtable,
* ----------------------------------------------------------------
*/
HeapTuple
ExecScanHashBucket(HashJoinState * hjstate,
ExecScanHashBucket(HashJoinState *hjstate,
HashBucket bucket,
HeapTuple curtuple,
List * hjclauses,
ExprContext * econtext)
List *hjclauses,
ExprContext *econtext)
{
HeapTuple heapTuple;
bool qualResult;
@ -826,7 +826,7 @@ hashFunc(char *key, int len)
* ----------------------------------------------------------------
*/
static int
ExecHashPartition(Hash * node)
ExecHashPartition(Hash *node)
{
Plan *outerNode;
int b;

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.7 1997/09/08 02:22:43 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.8 1997/09/08 21:43:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -33,17 +33,17 @@
#include "utils/palloc.h"
static TupleTableSlot *
ExecHashJoinOuterGetTuple(Plan * node, Plan * parent, HashJoinState * hjstate);
ExecHashJoinOuterGetTuple(Plan *node, Plan *parent, HashJoinState *hjstate);
static TupleTableSlot *
ExecHashJoinGetSavedTuple(HashJoinState * hjstate, char *buffer,
File file, TupleTableSlot * tupleSlot, int *block, char **position);
ExecHashJoinGetSavedTuple(HashJoinState *hjstate, char *buffer,
File file, TupleTableSlot *tupleSlot, int *block, char **position);
static int
ExecHashJoinGetBatch(int bucketno, HashJoinTable hashtable,
int nbatch);
static int ExecHashJoinNewBatch(HashJoinState * hjstate);
static int ExecHashJoinNewBatch(HashJoinState *hjstate);
@ -57,7 +57,7 @@ static int ExecHashJoinNewBatch(HashJoinState * hjstate);
* ----------------------------------------------------------------
*/
TupleTableSlot * /* return: a tuple or NULL */
ExecHashJoin(HashJoin * node)
ExecHashJoin(HashJoin *node)
{
HashJoinState *hjstate;
EState *estate;
@ -392,7 +392,7 @@ ExecHashJoin(HashJoin * node)
* ----------------------------------------------------------------
*/
bool /* return: initialization status */
ExecInitHashJoin(HashJoin * node, EState * estate, Plan * parent)
ExecInitHashJoin(HashJoin *node, EState *estate, Plan *parent)
{
HashJoinState *hjstate;
Plan *outerNode;
@ -497,7 +497,7 @@ ExecInitHashJoin(HashJoin * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsHashJoin(HashJoin * node)
ExecCountSlotsHashJoin(HashJoin *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
@ -511,7 +511,7 @@ ExecCountSlotsHashJoin(HashJoin * node)
* ----------------------------------------------------------------
*/
void
ExecEndHashJoin(HashJoin * node)
ExecEndHashJoin(HashJoin *node)
{
HashJoinState *hjstate;
@ -569,7 +569,7 @@ ExecEndHashJoin(HashJoin * node)
*/
static TupleTableSlot *
ExecHashJoinOuterGetTuple(Plan * node, Plan * parent, HashJoinState * hjstate)
ExecHashJoinOuterGetTuple(Plan *node, Plan *parent, HashJoinState *hjstate)
{
TupleTableSlot *slot;
HashJoinTable hashtable;
@ -619,10 +619,10 @@ ExecHashJoinOuterGetTuple(Plan * node, Plan * parent, HashJoinState * hjstate)
*/
static TupleTableSlot *
ExecHashJoinGetSavedTuple(HashJoinState * hjstate,
ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
char *buffer,
File file,
TupleTableSlot * tupleSlot,
TupleTableSlot *tupleSlot,
int *block, /* return parameter */
char **position) /* return parameter */
{
@ -664,7 +664,7 @@ ExecHashJoinGetSavedTuple(HashJoinState * hjstate,
* ----------------------------------------------------------------
*/
static int
ExecHashJoinNewBatch(HashJoinState * hjstate)
ExecHashJoinNewBatch(HashJoinState *hjstate)
{
File *innerBatches;
File *outerBatches;

28
src/backend/executor/nodeIndexscan.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.9 1997/09/08 02:22:44 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.10 1997/09/08 21:43:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -55,7 +55,7 @@
#define LEFT_OP 1
#define RIGHT_OP 2
static TupleTableSlot *IndexNext(IndexScan * node);
static TupleTableSlot *IndexNext(IndexScan *node);
/* ----------------------------------------------------------------
* IndexNext
@ -80,7 +80,7 @@ static TupleTableSlot *IndexNext(IndexScan * node);
* ----------------------------------------------------------------
*/
static TupleTableSlot *
IndexNext(IndexScan * node)
IndexNext(IndexScan *node)
{
EState *estate;
CommonScanState *scanstate;
@ -192,7 +192,7 @@ IndexNext(IndexScan * node)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecIndexScan(IndexScan * node)
ExecIndexScan(IndexScan *node)
{
TupleTableSlot *returnTuple;
@ -217,7 +217,7 @@ ExecIndexScan(IndexScan * node)
* ----------------------------------------------------------------
*/
void
ExecIndexReScan(IndexScan * node, ExprContext * exprCtxt, Plan * parent)
ExecIndexReScan(IndexScan *node, ExprContext *exprCtxt, Plan *parent)
{
EState *estate;
IndexScanState *indexstate;
@ -331,7 +331,7 @@ ExecIndexReScan(IndexScan * node, ExprContext * exprCtxt, Plan * parent)
* ----------------------------------------------------------------
*/
void
ExecEndIndexScan(IndexScan * node)
ExecEndIndexScan(IndexScan *node)
{
CommonScanState *scanstate;
IndexScanState *indexstate;
@ -395,7 +395,7 @@ ExecEndIndexScan(IndexScan * node)
* ----------------------------------------------------------------
*/
void
ExecIndexMarkPos(IndexScan * node)
ExecIndexMarkPos(IndexScan *node)
{
IndexScanState *indexstate;
IndexScanDescPtr indexScanDescs;
@ -426,7 +426,7 @@ ExecIndexMarkPos(IndexScan * node)
* ----------------------------------------------------------------
*/
void
ExecIndexRestrPos(IndexScan * node)
ExecIndexRestrPos(IndexScan *node)
{
IndexScanState *indexstate;
IndexScanDescPtr indexScanDescs;
@ -461,7 +461,7 @@ ExecIndexRestrPos(IndexScan * node)
* ----------------------------------------------------------------
*/
bool
ExecInitIndexScan(IndexScan * node, EState * estate, Plan * parent)
ExecInitIndexScan(IndexScan *node, EState *estate, Plan *parent)
{
IndexScanState *indexstate;
CommonScanState *scanstate;
@ -677,7 +677,7 @@ ExecInitIndexScan(IndexScan * node, EState * estate, Plan * parent)
*/
leftop = (Node *) get_leftop(clause);
if (IsA(leftop, Var) && var_is_rel((Var *) leftop))
if (IsA(leftop, Var) &&var_is_rel((Var *) leftop))
{
/* ----------------
* if the leftop is a "rel-var", then it means
@ -750,7 +750,7 @@ ExecInitIndexScan(IndexScan * node, EState * estate, Plan * parent)
*/
rightop = (Node *) get_rightop(clause);
if (IsA(rightop, Var) && var_is_rel((Var *) rightop))
if (IsA(rightop, Var) &&var_is_rel((Var *) rightop))
{
/* ----------------
* here we make sure only one op identifies the
@ -920,7 +920,7 @@ ExecInitIndexScan(IndexScan * node, EState * estate, Plan * parent)
direction, /* scan direction */
timeQual, /* time qual */
&currentRelation, /* return: rel desc */
(Pointer *) & currentScanDesc); /* return: scan desc */
(Pointer *) &currentScanDesc); /* return: scan desc */
scanstate->css_currentRelation = currentRelation;
scanstate->css_currentScanDesc = currentScanDesc;
@ -959,7 +959,7 @@ ExecInitIndexScan(IndexScan * node, EState * estate, Plan * parent)
direction, /* scan direction */
timeQual, /* time qual */
&(relationDescs[i]), /* return: rel desc */
(Pointer *) & (scanDescs[i]));
(Pointer *) &(scanDescs[i]));
/* return: scan desc */
}
}
@ -977,7 +977,7 @@ ExecInitIndexScan(IndexScan * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsIndexScan(IndexScan * node)
ExecCountSlotsIndexScan(IndexScan *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) +

10
src/backend/executor/nodeMaterial.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMaterial.c,v 1.8 1997/09/08 02:22:45 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMaterial.c,v 1.9 1997/09/08 21:43:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -48,7 +48,7 @@
* ----------------------------------------------------------------
*/
TupleTableSlot * /* result tuple from subplan */
ExecMaterial(Material * node)
ExecMaterial(Material *node)
{
EState *estate;
MaterialState *matstate;
@ -188,7 +188,7 @@ ExecMaterial(Material * node)
* ----------------------------------------------------------------
*/
bool /* initialization status */
ExecInitMaterial(Material * node, EState * estate, Plan * parent)
ExecInitMaterial(Material *node, EState *estate, Plan *parent)
{
MaterialState *matstate;
Plan *outerPlan;
@ -291,7 +291,7 @@ ExecInitMaterial(Material * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsMaterial(Material * node)
ExecCountSlotsMaterial(Material *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) +
@ -306,7 +306,7 @@ ExecCountSlotsMaterial(Material * node)
* ----------------------------------------------------------------
*/
void
ExecEndMaterial(Material * node)
ExecEndMaterial(Material *node)
{
MaterialState *matstate;
Relation tempRelation;

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.11 1997/09/08 20:55:45 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.12 1997/09/08 21:43:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -84,7 +84,7 @@
#include "utils/lsyscache.h"
#include "utils/psort.h"
static bool MergeCompare(List * eqQual, List * compareQual, ExprContext * econtext);
static bool MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext);
/* ----------------------------------------------------------------
* MarkInnerTuple and RestoreInnerTuple macros
@ -143,7 +143,7 @@ static bool MergeCompare(List * eqQual, List * compareQual, ExprContext * econte
* ----------------------------------------------------------------
*/
static List *
MJFormOSortopI(List * qualList, Oid sortOp)
MJFormOSortopI(List *qualList, Oid sortOp)
{
List *qualCopy;
List *qualcdr;
@ -207,7 +207,7 @@ MJFormOSortopI(List * qualList, Oid sortOp)
* ----------------------------------------------------------------
*/
static List *
MJFormISortopO(List * qualList, Oid sortOp)
MJFormISortopO(List *qualList, Oid sortOp)
{
List *ISortopO;
List *qualcdr;
@ -258,7 +258,7 @@ MJFormISortopO(List * qualList, Oid sortOp)
* ----------------------------------------------------------------
*/
static bool
MergeCompare(List * eqQual, List * compareQual, ExprContext * econtext)
MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext)
{
List *clause;
List *eqclause;
@ -328,7 +328,7 @@ MergeCompare(List * eqQual, List * compareQual, ExprContext * econtext)
*/
#ifdef EXEC_MERGEJOINDEBUG
void
ExecMergeTupleDumpInner(ExprContext * econtext)
ExecMergeTupleDumpInner(ExprContext *econtext)
{
TupleTableSlot *innerSlot;
@ -342,7 +342,7 @@ ExecMergeTupleDumpInner(ExprContext * econtext)
}
void
ExecMergeTupleDumpOuter(ExprContext * econtext)
ExecMergeTupleDumpOuter(ExprContext *econtext)
{
TupleTableSlot *outerSlot;
@ -356,8 +356,8 @@ ExecMergeTupleDumpOuter(ExprContext * econtext)
}
void
ExecMergeTupleDumpMarked(ExprContext * econtext,
MergeJoinState * mergestate)
ExecMergeTupleDumpMarked(ExprContext *econtext,
MergeJoinState *mergestate)
{
TupleTableSlot *markedSlot;
@ -372,7 +372,7 @@ ExecMergeTupleDumpMarked(ExprContext * econtext,
}
void
ExecMergeTupleDump(ExprContext * econtext, MergeJoinState * mergestate)
ExecMergeTupleDump(ExprContext *econtext, MergeJoinState *mergestate)
{
printf("******** ExecMergeTupleDump ********\n");
@ -386,7 +386,7 @@ ExecMergeTupleDump(ExprContext * econtext, MergeJoinState * mergestate)
#endif
static void
CleanUpSort(Plan * plan)
CleanUpSort(Plan *plan)
{
if (plan == NULL)
@ -449,7 +449,7 @@ CleanUpSort(Plan * plan)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecMergeJoin(MergeJoin * node)
ExecMergeJoin(MergeJoin *node)
{
EState *estate;
MergeJoinState *mergestate;
@ -749,7 +749,8 @@ ExecMergeJoin(MergeJoin * node)
*
* new outer tuple > marked tuple
*
******************************
*****************************
*
*
*
*
@ -830,7 +831,8 @@ ExecMergeJoin(MergeJoin * node)
* we have to advance the outer scan until we find the outer
* 8.
*
******************************
*****************************
*
*
*
*
@ -933,7 +935,8 @@ ExecMergeJoin(MergeJoin * node)
* we have to advance the inner scan until we find the inner
* 12.
*
******************************
*****************************
*
*
*
*
@ -1065,7 +1068,7 @@ ExecMergeJoin(MergeJoin * node)
* ----------------------------------------------------------------
*/
bool
ExecInitMergeJoin(MergeJoin * node, EState * estate, Plan * parent)
ExecInitMergeJoin(MergeJoin *node, EState *estate, Plan *parent)
{
MergeJoinState *mergestate;
List *joinclauses;
@ -1185,7 +1188,7 @@ ExecInitMergeJoin(MergeJoin * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsMergeJoin(MergeJoin * node)
ExecCountSlotsMergeJoin(MergeJoin *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) +
@ -1200,7 +1203,7 @@ ExecCountSlotsMergeJoin(MergeJoin * node)
* ----------------------------------------------------------------
*/
void
ExecEndMergeJoin(MergeJoin * node)
ExecEndMergeJoin(MergeJoin *node)
{
MergeJoinState *mergestate;

12
src/backend/executor/nodeNestloop.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeNestloop.c,v 1.6 1997/09/08 20:55:46 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeNestloop.c,v 1.7 1997/09/08 21:43:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -55,7 +55,7 @@
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecNestLoop(NestLoop * node, Plan * parent)
ExecNestLoop(NestLoop *node, Plan *parent)
{
NestLoopState *nlstate;
Plan *innerPlan;
@ -86,7 +86,7 @@ ExecNestLoop(NestLoop * node, Plan * parent)
*/
econtext = nlstate->jstate.cs_ExprContext;
/* ---------------- * get the current outer tuple
/* ---------------- * get the current outer tuple
* ----------------
*/
outerTupleSlot = nlstate->jstate.cs_OuterTupleSlot;
@ -265,7 +265,7 @@ ExecNestLoop(NestLoop * node, Plan * parent)
* ----------------------------------------------------------------
*/
bool
ExecInitNestLoop(NestLoop * node, EState * estate, Plan * parent)
ExecInitNestLoop(NestLoop *node, EState *estate, Plan *parent)
{
NestLoopState *nlstate;
@ -331,7 +331,7 @@ ExecInitNestLoop(NestLoop * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsNestLoop(NestLoop * node)
ExecCountSlotsNestLoop(NestLoop *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
@ -345,7 +345,7 @@ ExecCountSlotsNestLoop(NestLoop * node)
* ----------------------------------------------------------------
*/
void
ExecEndNestLoop(NestLoop * node)
ExecEndNestLoop(NestLoop *node)
{
NestLoopState *nlstate;

10
src/backend/executor/nodeResult.c
View File

@ -27,7 +27,7 @@
* SeqScan (emp.all)
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeResult.c,v 1.4 1997/09/08 02:22:49 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeResult.c,v 1.5 1997/09/08 21:43:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -51,7 +51,7 @@
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecResult(Result * node)
ExecResult(Result *node)
{
ResultState *resstate;
TupleTableSlot *outerTupleSlot;
@ -189,7 +189,7 @@ ExecResult(Result * node)
* ----------------------------------------------------------------
*/
bool
ExecInitResult(Result * node, EState * estate, Plan * parent)
ExecInitResult(Result *node, EState *estate, Plan *parent)
{
ResultState *resstate;
@ -253,7 +253,7 @@ ExecInitResult(Result * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsResult(Result * node)
ExecCountSlotsResult(Result *node)
{
return ExecCountSlotsNode(outerPlan(node)) + RESULT_NSLOTS;
}
@ -265,7 +265,7 @@ ExecCountSlotsResult(Result * node)
* ----------------------------------------------------------------
*/
void
ExecEndResult(Result * node)
ExecEndResult(Result *node)
{
ResultState *resstate;

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.6 1997/09/08 02:22:50 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.7 1997/09/08 21:43:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -31,10 +31,10 @@
#include "parser/parsetree.h"
static Oid
InitScanRelation(SeqScan * node, EState * estate,
CommonScanState * scanstate, Plan * outerPlan);
InitScanRelation(SeqScan *node, EState *estate,
CommonScanState *scanstate, Plan *outerPlan);
static TupleTableSlot *SeqNext(SeqScan * node);
static TupleTableSlot *SeqNext(SeqScan *node);
/* ----------------------------------------------------------------
* Scan Support
@ -47,7 +47,7 @@ static TupleTableSlot *SeqNext(SeqScan * node);
* ----------------------------------------------------------------
*/
static TupleTableSlot *
SeqNext(SeqScan * node)
SeqNext(SeqScan *node)
{
HeapTuple tuple;
HeapScanDesc scandesc;
@ -115,7 +115,7 @@ SeqNext(SeqScan * node)
*/
TupleTableSlot *
ExecSeqScan(SeqScan * node)
ExecSeqScan(SeqScan *node)
{
TupleTableSlot *slot;
Plan *outerPlan;
@ -151,8 +151,8 @@ ExecSeqScan(SeqScan * node)
* ----------------------------------------------------------------
*/
static Oid
InitScanRelation(SeqScan * node, EState * estate,
CommonScanState * scanstate, Plan * outerPlan)
InitScanRelation(SeqScan *node, EState *estate,
CommonScanState *scanstate, Plan *outerPlan)
{
Index relid;
List *rangeTable;
@ -190,7 +190,7 @@ InitScanRelation(SeqScan * node, EState * estate,
direction,/* scan direction */
timeQual, /* time qual */
&currentRelation, /* return: rel desc */
(Pointer *) & currentScanDesc); /* return: scan desc */
(Pointer *) &currentScanDesc); /* return: scan desc */
scanstate->css_currentRelation = currentRelation;
scanstate->css_currentScanDesc = currentScanDesc;
@ -236,7 +236,7 @@ InitScanRelation(SeqScan * node, EState * estate,
* ----------------------------------------------------------------
*/
bool
ExecInitSeqScan(SeqScan * node, EState * estate, Plan * parent)
ExecInitSeqScan(SeqScan *node, EState *estate, Plan *parent)
{
CommonScanState *scanstate;
Plan *outerPlan;
@ -296,7 +296,7 @@ ExecInitSeqScan(SeqScan * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsSeqScan(SeqScan * node)
ExecCountSlotsSeqScan(SeqScan *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
@ -312,7 +312,7 @@ ExecCountSlotsSeqScan(SeqScan * node)
* ----------------------------------------------------------------
*/
void
ExecEndSeqScan(SeqScan * node)
ExecEndSeqScan(SeqScan *node)
{
CommonScanState *scanstate;
Plan *outerPlan;
@ -366,7 +366,7 @@ ExecEndSeqScan(SeqScan * node)
* ----------------------------------------------------------------
*/
void
ExecSeqReScan(SeqScan * node, ExprContext * exprCtxt, Plan * parent)
ExecSeqReScan(SeqScan *node, ExprContext *exprCtxt, Plan *parent)
{
CommonScanState *scanstate;
EState *estate;
@ -403,7 +403,7 @@ ExecSeqReScan(SeqScan * node, ExprContext * exprCtxt, Plan * parent)
* ----------------------------------------------------------------
*/
void
ExecSeqMarkPos(SeqScan * node)
ExecSeqMarkPos(SeqScan *node)
{
CommonScanState *scanstate;
Plan *outerPlan;
@ -442,7 +442,7 @@ ExecSeqMarkPos(SeqScan * node)
* ----------------------------------------------------------------
*/
void
ExecSeqRestrPos(SeqScan * node)
ExecSeqRestrPos(SeqScan *node)
{
CommonScanState *scanstate;
Plan *outerPlan;

16
src/backend/executor/nodeSort.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.8 1997/09/08 02:22:50 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.9 1997/09/08 21:43:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -33,7 +33,7 @@
* ----------------------------------------------------------------
*/
static ScanKey
FormSortKeys(Sort * sortnode)
FormSortKeys(Sort *sortnode)
{
ScanKey sortkeys;
List *targetList;
@ -102,7 +102,7 @@ FormSortKeys(Sort * sortnode)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecSort(Sort * node)
ExecSort(Sort *node)
{
EState *estate;
SortState *sortstate;
@ -229,7 +229,7 @@ ExecSort(Sort * node)
* ----------------------------------------------------------------
*/
bool
ExecInitSort(Sort * node, EState * estate, Plan * parent)
ExecInitSort(Sort *node, EState *estate, Plan *parent)
{
SortState *sortstate;
Plan *outerPlan;
@ -314,7 +314,7 @@ ExecInitSort(Sort * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsSort(Sort * node)
ExecCountSlotsSort(Sort *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) +
@ -328,7 +328,7 @@ ExecCountSlotsSort(Sort * node)
* ----------------------------------------------------------------
*/
void
ExecEndSort(Sort * node)
ExecEndSort(Sort *node)
{
SortState *sortstate;
Plan *outerPlan;
@ -369,7 +369,7 @@ ExecEndSort(Sort * node)
* ----------------------------------------------------------------
*/
void
ExecSortMarkPos(Sort * node)
ExecSortMarkPos(Sort *node)
{
SortState *sortstate;
@ -393,7 +393,7 @@ ExecSortMarkPos(Sort * node)
* ----------------------------------------------------------------
*/
void
ExecSortRestrPos(Sort * node)
ExecSortRestrPos(Sort *node)
{
SortState *sortstate;

14
src/backend/executor/nodeTee.c
View File

@ -15,7 +15,7 @@
* ExecEndTee
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/nodeTee.c,v 1.8 1997/09/08 02:22:51 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/nodeTee.c,v 1.9 1997/09/08 21:43:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -45,7 +45,7 @@
* ------------------------------------------------------------------
*/
bool
ExecInitTee(Tee * node, EState * currentEstate, Plan * parent)
ExecInitTee(Tee *node, EState *currentEstate, Plan *parent)
{
TeeState *teeState;
Plan *outerPlan;
@ -214,7 +214,7 @@ ExecInitTee(Tee * node, EState * currentEstate, Plan * parent)
}
int
ExecCountSlotsTee(Tee * node)
ExecCountSlotsTee(Tee *node)
{
/* Tee nodes can't have innerPlans */
return ExecCountSlotsNode(outerPlan(node)) + TEE_NSLOTS;
@ -230,7 +230,7 @@ ExecCountSlotsTee(Tee * node)
* ----------------------------------------------------------------
*/
static void
initTeeScanDescs(Tee * node)
initTeeScanDescs(Tee *node)
{
TeeState *teeState;
Relation bufferRel;
@ -290,7 +290,7 @@ initTeeScanDescs(Tee * node)
*/
TupleTableSlot *
ExecTee(Tee * node, Plan * parent)
ExecTee(Tee *node, Plan *parent)
{
EState *estate;
TeeState *teeState;
@ -443,7 +443,7 @@ ExecTee(Tee * node, Plan * parent)
* ----------------------------------------------------------------
*/
void
ExecTeeReScan(Tee * node, ExprContext * exprCtxt, Plan * parent)
ExecTeeReScan(Tee *node, ExprContext *exprCtxt, Plan *parent)
{
EState *estate;
@ -490,7 +490,7 @@ ExecTeeReScan(Tee * node, ExprContext * exprCtxt, Plan * parent)
*/
void
ExecEndTee(Tee * node, Plan * parent)
ExecEndTee(Tee *node, Plan *parent)
{
EState *estate;
TeeState *teeState;

14
src/backend/executor/nodeUnique.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeUnique.c,v 1.9 1997/09/08 02:22:52 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeUnique.c,v 1.10 1997/09/08 21:43:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -47,9 +47,9 @@
* same ADT value. -cim
* ----------------------------------------------------------------
*/
static bool /* true if tuples are identical, false
static bool /* true if tuples are identical, false
* otherwise */
ExecIdenticalTuples(TupleTableSlot * t1, TupleTableSlot * t2)
ExecIdenticalTuples(TupleTableSlot *t1, TupleTableSlot *t2)
{
HeapTuple h1;
HeapTuple h2;
@ -108,7 +108,7 @@ ExecIdenticalTuples(TupleTableSlot * t1, TupleTableSlot * t2)
* ----------------------------------------------------------------
*/
TupleTableSlot * /* return: a tuple or NULL */
ExecUnique(Unique * node)
ExecUnique(Unique *node)
{
UniqueState *uniquestate;
TupleTableSlot *resultTupleSlot;
@ -243,7 +243,7 @@ ExecUnique(Unique * node)
* ----------------------------------------------------------------
*/
bool /* return: initialization status */
ExecInitUnique(Unique * node, EState * estate, Plan * parent)
ExecInitUnique(Unique *node, EState *estate, Plan *parent)
{
UniqueState *uniquestate;
Plan *outerPlan;
@ -323,7 +323,7 @@ ExecInitUnique(Unique * node, EState * estate, Plan * parent)
}
int
ExecCountSlotsUnique(Unique * node)
ExecCountSlotsUnique(Unique *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
@ -338,7 +338,7 @@ ExecCountSlotsUnique(Unique * node)
* ----------------------------------------------------------------
*/
void
ExecEndUnique(Unique * node)
ExecEndUnique(Unique *node)
{
UniqueState *uniquestate;

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

@ -17,7 +17,7 @@ typedef struct
Portal portal; /* portal per procedure */
MemoryContext savedcxt;
CommandId savedId;
} _SPI_connection;
} _SPI_connection;
static Portal _SPI_portal = (Portal) NULL;
static _SPI_connection *_SPI_stack = NULL;
@ -37,20 +37,20 @@ typedef struct
List *ptlist;
int nargs;
Oid *argtypes;
} _SPI_plan;
} _SPI_plan;
static int _SPI_execute(char *src, int tcount, _SPI_plan * plan);
static int _SPI_pquery(QueryDesc * queryDesc, EState * state, int tcount);
static int _SPI_execute(char *src, int tcount, _SPI_plan *plan);
static int _SPI_pquery(QueryDesc *queryDesc, EState *state, int tcount);
#if 0
static void _SPI_fetch(FetchStmt * stmt);
static void _SPI_fetch(FetchStmt *stmt);
#endif
static int
_SPI_execute_plan(_SPI_plan * plan,
_SPI_execute_plan(_SPI_plan *plan,
char **Values, char *Nulls, int tcount);
static _SPI_plan *_SPI_copy_plan(_SPI_plan * plan, bool local);
static _SPI_plan *_SPI_copy_plan(_SPI_plan *plan, bool local);
static int _SPI_begin_call(bool execmem);
static int _SPI_end_call(bool procmem);
@ -217,7 +217,7 @@ SPI_execp(void *plan, char **Values, char *Nulls, int tcount)
}
void *
SPI_prepare(char *src, int nargs, Oid * argtypes)
SPI_prepare(char *src, int nargs, Oid *argtypes)
{
_SPI_plan *plan;
@ -320,7 +320,7 @@ SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
}
char *
SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool * isnull)
SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
{
char *val;
@ -457,7 +457,7 @@ spi_printtup(HeapTuple tuple, TupleDesc tupdesc)
*/
static int
_SPI_execute(char *src, int tcount, _SPI_plan * plan)
_SPI_execute(char *src, int tcount, _SPI_plan *plan)
{
QueryTreeList *queryTree_list;
List *planTree_list;
@ -554,7 +554,7 @@ _SPI_execute(char *src, int tcount, _SPI_plan * plan)
}
static int
_SPI_execute_plan(_SPI_plan * plan, char **Values, char *Nulls, int tcount)
_SPI_execute_plan(_SPI_plan *plan, char **Values, char *Nulls, int tcount)
{
QueryTreeList *queryTree_list = plan->qtlist;
List *planTree_list = plan->ptlist;
@ -625,7 +625,7 @@ _SPI_execute_plan(_SPI_plan * plan, char **Values, char *Nulls, int tcount)
}
static int
_SPI_pquery(QueryDesc * queryDesc, EState * state, int tcount)
_SPI_pquery(QueryDesc *queryDesc, EState *state, int tcount)
{
Query *parseTree;
Plan *plan;
@ -723,7 +723,7 @@ _SPI_pquery(QueryDesc * queryDesc, EState * state, int tcount)
#if 0
static void
_SPI_fetch(FetchStmt * stmt)
_SPI_fetch(FetchStmt *stmt)
{
char *name = stmt->portalname;
int feature = (stmt->direction == FORWARD) ? EXEC_FOR : EXEC_BACK;
@ -864,7 +864,7 @@ _SPI_checktuples(bool isRetrieveIntoRelation)
}
static _SPI_plan *
_SPI_copy_plan(_SPI_plan * plan, bool local)
_SPI_copy_plan(_SPI_plan *plan, bool local)
{
_SPI_plan *newplan;
MemoryContext oldcxt;