mirrors/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Clean up existing debugging print statements.

Browse Source 
Modify comment blocks to insulate from pgindent.
This commit is contained in:
Thomas G. Lockhart 1998-09-25 13:38:32 +00:00
parent ee88006cf2
commit 4327a3675f
3 changed files with 218 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,7 +26,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.55 1998/09/01 04:28:16 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.56 1998/09/25 13:38:30 thomas Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -168,16 +168,16 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count)
CommandDest dest; CommandDest dest;
void (*destination) (); void (*destination) ();
/* ---------------- /******************
* sanity checks * sanity checks
* ---------------- ******************
*/ */
Assert(queryDesc != NULL); Assert(queryDesc != NULL);
/* ---------------- /******************
* extract information from the query descriptor * extract information from the query descriptor
* and the query feature. * and the query feature.
* ---------------- ******************
*/ */
operation = queryDesc->operation; operation = queryDesc->operation;
parseTree = queryDesc->parsetree; parseTree = queryDesc->parsetree;
@ -209,9 +209,9 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count)
destination); destination);
break; break;
/* ---------------- /******************
* retrieve next n "backward" tuples * retrieve next n "backward" tuples
* ---------------- ******************
*/ */
case EXEC_BACK: case EXEC_BACK:
result = ExecutePlan(estate, result = ExecutePlan(estate,
@ -223,10 +223,10 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count)
destination); destination);
break; break;
/* ---------------- /******************
* return one tuple but don't "retrieve" it. * return one tuple but don't "retrieve" it.
* (this is used by the rule manager..) -cim 9/14/89 * (this is used by the rule manager..) -cim 9/14/89
* ---------------- ******************
*/ */
case EXEC_RETONE: case EXEC_RETONE:
result = ExecutePlan(estate, result = ExecutePlan(estate,
@ -389,40 +389,40 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
List *targetList; List *targetList;
int len; int len;
/* ---------------- /******************
* get information from query descriptor * get information from query descriptor
* ---------------- ******************
*/ */
rangeTable = parseTree->rtable; rangeTable = parseTree->rtable;
resultRelation = parseTree->resultRelation; resultRelation = parseTree->resultRelation;
/* ---------------- /******************
* initialize the node's execution state * initialize the node's execution state
* ---------------- ******************
*/ */
estate->es_range_table = rangeTable; estate->es_range_table = rangeTable;
/* ---------------- /******************
* initialize the BaseId counter so node base_id's * initialize the BaseId counter so node base_id's
* are assigned correctly. Someday baseid's will have to * are assigned correctly. Someday baseid's will have to
* be stored someplace other than estate because they * be stored someplace other than estate because they
* should be unique per query planned. * should be unique per query planned.
* ---------------- ******************
*/ */
estate->es_BaseId = 1; estate->es_BaseId = 1;
/* ---------------- /******************
* initialize result relation stuff * initialize result relation stuff
* ---------------- ******************
*/ */
if (resultRelation != 0 && operation != CMD_SELECT) if (resultRelation != 0 && operation != CMD_SELECT)
{ {
/* ---------------- /******************
* if we have a result relation, open it and * if we have a result relation, open it and
* initialize the result relation info stuff. * initialize the result relation info stuff.
* ---------------- ******************
*/ */
RelationInfo *resultRelationInfo; RelationInfo *resultRelationInfo;
Index resultRelationIndex; Index resultRelationIndex;
@ -455,10 +455,10 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
resultRelationInfo->ri_IndexRelationDescs = NULL; resultRelationInfo->ri_IndexRelationDescs = NULL;
resultRelationInfo->ri_IndexRelationInfo = NULL; resultRelationInfo->ri_IndexRelationInfo = NULL;
/* ---------------- /******************
* open indices on result relation and save descriptors * open indices on result relation and save descriptors
* in the result relation information.. * in the result relation information..
* ---------------- ******************
*/ */
ExecOpenIndices(resultRelationOid, resultRelationInfo); ExecOpenIndices(resultRelationOid, resultRelationInfo);
@ -466,9 +466,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
} }
else else
{ {
/* ---------------- /******************
* if no result relation, then set state appropriately * if no result relation, then set state appropriately
* ---------------- ******************
*/ */
estate->es_result_relation_info = NULL; estate->es_result_relation_info = NULL;
} }
@ -477,9 +477,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
ExecCheckPerms(operation, resultRelation, rangeTable, parseTree); ExecCheckPerms(operation, resultRelation, rangeTable, parseTree);
#endif #endif
/* ---------------- /******************
* initialize the executor "tuple" table. * initialize the executor "tuple" table.
* ---------------- ******************
*/ */
{ {
int nSlots = ExecCountSlotsNode(plan); int nSlots = ExecCountSlotsNode(plan);
@ -488,33 +488,33 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
estate->es_tupleTable = tupleTable; estate->es_tupleTable = tupleTable;
} }
/* ---------------- /******************
* initialize the private state information for * initialize the private state information for
* all the nodes in the query tree. This opens * all the nodes in the query tree. This opens
* files, allocates storage and leaves us ready * files, allocates storage and leaves us ready
* to start processing tuples.. * to start processing tuples..
* ---------------- ******************
*/ */
ExecInitNode(plan, estate, NULL); ExecInitNode(plan, estate, NULL);
/* ---------------- /******************
* get the tuple descriptor describing the type * get the tuple descriptor describing the type
* of tuples to return.. (this is especially important * of tuples to return.. (this is especially important
* if we are creating a relation with "retrieve into") * if we are creating a relation with "retrieve into")
* ---------------- ******************
*/ */
tupType = ExecGetTupType(plan); /* tuple descriptor */ tupType = ExecGetTupType(plan); /* tuple descriptor */
targetList = plan->targetlist; targetList = plan->targetlist;
len = ExecTargetListLength(targetList); /* number of attributes */ len = ExecTargetListLength(targetList); /* number of attributes */
/* ---------------- /******************
* now that we have the target list, initialize the junk filter * now that we have the target list, initialize the junk filter
* if this is a REPLACE or a DELETE query. * if this is a REPLACE or a DELETE query.
* We also init the junk filter if this is an append query * We also init the junk filter if this is an append query
* (there might be some rule lock info there...) * (there might be some rule lock info there...)
* NOTE: in the future we might want to initialize the junk * NOTE: in the future we might want to initialize the junk
* filter for all queries. * filter for all queries.
* ---------------- ******************
* SELECT added by daveh@insightdist.com 5/20/98 to allow * SELECT added by daveh@insightdist.com 5/20/98 to allow
* ORDER/GROUP BY have an identifier missing from the target. * ORDER/GROUP BY have an identifier missing from the target.
*/ */
@ -551,9 +551,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
estate->es_junkFilter = NULL; estate->es_junkFilter = NULL;
} }
/* ---------------- /******************
* initialize the "into" relation * initialize the "into" relation
* ---------------- ******************
*/ */
intoRelationDesc = (Relation) NULL; intoRelationDesc = (Relation) NULL;
@ -571,9 +571,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
*/ */
if (parseTree->into != NULL) if (parseTree->into != NULL)
{ {
/* ---------------- /******************
* create the "into" relation * create the "into" relation
* ---------------- ******************
*/ */
intoName = parseTree->into; intoName = parseTree->into;
@ -587,11 +587,11 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
FreeTupleDesc(tupdesc); FreeTupleDesc(tupdesc);
/* ---------------- /******************
* XXX rather than having to call setheapoverride(true) * XXX rather than having to call setheapoverride(true)
* and then back to false, we should change the * and then back to false, we should change the
* arguments to heap_open() instead.. * arguments to heap_open() instead..
* ---------------- ******************
*/ */
setheapoverride(true); setheapoverride(true);
@ -619,22 +619,22 @@ EndPlan(Plan *plan, EState *estate)
RelationInfo *resultRelationInfo; RelationInfo *resultRelationInfo;
Relation intoRelationDesc; Relation intoRelationDesc;
/* ---------------- /******************
* get information from state * get information from state
* ---------------- ******************
*/ */
resultRelationInfo = estate->es_result_relation_info; resultRelationInfo = estate->es_result_relation_info;
intoRelationDesc = estate->es_into_relation_descriptor; intoRelationDesc = estate->es_into_relation_descriptor;
/* ---------------- /******************
* shut down the query * shut down the query
* ---------------- ******************
*/ */
ExecEndNode(plan, plan); ExecEndNode(plan, plan);
/* ---------------- /******************
* destroy the executor "tuple" table. * destroy the executor "tuple" table.
* ---------------- ******************
*/ */
{ {
TupleTable tupleTable = (TupleTable) estate->es_tupleTable; TupleTable tupleTable = (TupleTable) estate->es_tupleTable;
@ -643,9 +643,9 @@ EndPlan(Plan *plan, EState *estate)
estate->es_tupleTable = NULL; estate->es_tupleTable = NULL;
} }
/* ---------------- /******************
* close the result relations if necessary * close the result relations if necessary
* ---------------- ******************
*/ */
if (resultRelationInfo != NULL) if (resultRelationInfo != NULL)
{ {
@ -654,16 +654,16 @@ EndPlan(Plan *plan, EState *estate)
resultRelationDesc = resultRelationInfo->ri_RelationDesc; resultRelationDesc = resultRelationInfo->ri_RelationDesc;
heap_close(resultRelationDesc); heap_close(resultRelationDesc);
/* ---------------- /******************
* close indices on the result relation * close indices on the result relation
* ---------------- ******************
*/ */
ExecCloseIndices(resultRelationInfo); ExecCloseIndices(resultRelationInfo);
} }
/* ---------------- /******************
* close the "into" relation if necessary * close the "into" relation if necessary
* ---------------- ******************
*/ */
if (intoRelationDesc != NULL) if (intoRelationDesc != NULL)
heap_close(intoRelationDesc); heap_close(intoRelationDesc);
@ -702,42 +702,42 @@ ExecutePlan(EState *estate,
int current_tuple_count; int current_tuple_count;
TupleTableSlot *result; TupleTableSlot *result;
/* ---------------- /******************
* initialize local variables * initialize local variables
* ---------------- ******************
*/ */
slot = NULL; slot = NULL;
current_tuple_count = 0; current_tuple_count = 0;
result = NULL; result = NULL;
/* ---------------- /******************
* Set the direction. * Set the direction.
* ---------------- ******************
*/ */
estate->es_direction = direction; estate->es_direction = direction;
/* ---------------- /******************
* Loop until we've processed the proper number * Loop until we've processed the proper number
* of tuples from the plan.. * of tuples from the plan..
* ---------------- ******************
*/ */
for (;;) for (;;)
{ {
if (operation != CMD_NOTIFY) if (operation != CMD_NOTIFY)
{ {
/* ---------------- /******************
* Execute the plan and obtain a tuple * Execute the plan and obtain a tuple
* ---------------- ******************
*/ */
/* at the top level, the parent of a plan (2nd arg) is itself */ /* at the top level, the parent of a plan (2nd arg) is itself */
slot = ExecProcNode(plan, plan); slot = ExecProcNode(plan, plan);
/* ---------------- /******************
* if the tuple is null, then we assume * if the tuple is null, then we assume
* there is nothing more to process so * there is nothing more to process so
* we just return null... * we just return null...
* ---------------- ******************
*/ */
if (TupIsNull(slot)) if (TupIsNull(slot))
{ {
@ -746,15 +746,15 @@ ExecutePlan(EState *estate,
} }
} }
/* ---------------- /******************
* if we have a junk filter, then project a new * if we have a junk filter, then project a new
* tuple with the junk removed. * tuple with the junk removed.
* *
* Store this new "clean" tuple in the place of the * Store this new "clean" tuple in the place of the
* original tuple. * original tuple.
* *
* Also, extract all the junk ifnormation we need. * Also, extract all the junk information we need.
* ---------------- ******************
*/ */
if ((junkfilter = estate->es_junkFilter) != (JunkFilter *) NULL) if ((junkfilter = estate->es_junkFilter) != (JunkFilter *) NULL)
{ {
@ -764,9 +764,9 @@ ExecutePlan(EState *estate,
HeapTuple newTuple; HeapTuple newTuple;
bool isNull; bool isNull;
/* --------------- /******************
* extract the 'ctid' junk attribute. * extract the 'ctid' junk attribute.
* --------------- ******************
*/ */
if (operation == CMD_UPDATE || operation == CMD_DELETE) if (operation == CMD_UPDATE || operation == CMD_DELETE)
{ {
@ -786,10 +786,10 @@ ExecutePlan(EState *estate,
tupleid = &tuple_ctid; tupleid = &tuple_ctid;
} }
/* --------------- /******************
* Finally create a new "clean" tuple with all junk attributes * Finally create a new "clean" tuple with all junk attributes
* removed * removed
* --------------- ******************
*/ */
newTuple = ExecRemoveJunk(junkfilter, slot); newTuple = ExecRemoveJunk(junkfilter, slot);
@ -800,12 +800,12 @@ ExecutePlan(EState *estate,
true); /* tuple should be pfreed */ true); /* tuple should be pfreed */
} /* if (junkfilter... */ } /* if (junkfilter... */
/* ---------------- /******************
* now that we have a tuple, do the appropriate thing * now that we have a tuple, do the appropriate thing
* with it.. either return it to the user, add * with it.. either return it to the user, add
* it to a relation someplace, delete it from a * it to a relation someplace, delete it from a
* relation, or modify some of it's attributes. * relation, or modify some of it's attributes.
* ---------------- ******************
*/ */
switch (operation) switch (operation)
@ -855,21 +855,21 @@ ExecutePlan(EState *estate,
result = NULL; result = NULL;
break; break;
} }
/* ---------------- /******************
* check our tuple count.. if we've returned the * check our tuple count.. if we've returned the
* proper number then return, else loop again and * proper number then return, else loop again and
* process more tuples.. * process more tuples..
* ---------------- ******************
*/ */
current_tuple_count += 1; current_tuple_count += 1;
if (numberTuples == current_tuple_count) if (numberTuples == current_tuple_count)
break; break;
} }
/* ---------------- /******************
* here, result is either a slot containing a tuple in the case * here, result is either a slot containing a tuple in the case
* of a RETRIEVE or NULL otherwise. * of a RETRIEVE or NULL otherwise.
* ---------------- ******************
*/ */
return result; return result;
} }
@ -892,16 +892,16 @@ ExecRetrieve(TupleTableSlot *slot,
HeapTuple tuple; HeapTuple tuple;
TupleDesc attrtype; TupleDesc attrtype;
/* ---------------- /******************
* get the heap tuple out of the tuple table slot * get the heap tuple out of the tuple table slot
* ---------------- ******************
*/ */
tuple = slot->val; tuple = slot->val;
attrtype = slot->ttc_tupleDescriptor; attrtype = slot->ttc_tupleDescriptor;
/* ---------------- /******************
* insert the tuple into the "into relation" * insert the tuple into the "into relation"
* ---------------- ******************
*/ */
if (estate->es_into_relation_descriptor != NULL) if (estate->es_into_relation_descriptor != NULL)
{ {
@ -909,9 +909,9 @@ ExecRetrieve(TupleTableSlot *slot,
IncrAppended(); IncrAppended();
} }
/* ---------------- /******************
* send the tuple to the front end (or the screen) * send the tuple to the front end (or the screen)
* ---------------- ******************
*/ */
(*printfunc) (tuple, attrtype); (*printfunc) (tuple, attrtype);
IncrRetrieved(); IncrRetrieved();
@ -938,23 +938,23 @@ ExecAppend(TupleTableSlot *slot,
int numIndices; int numIndices;
Oid newId; Oid newId;
/* ---------------- /******************
* get the heap tuple out of the tuple table slot * get the heap tuple out of the tuple table slot
* ---------------- ******************
*/ */
tuple = slot->val; tuple = slot->val;
/* ---------------- /******************
* get information on the result relation * get information on the result relation
* ---------------- ******************
*/ */
resultRelationInfo = estate->es_result_relation_info; resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc; resultRelationDesc = resultRelationInfo->ri_RelationDesc;
/* ---------------- /******************
* have to add code to preform unique checking here. * have to add code to preform unique checking here.
* cim -12/1/89 * cim -12/1/89
* ---------------- ******************
*/ */
/* BEFORE ROW INSERT Triggers */ /* BEFORE ROW INSERT Triggers */
@ -976,9 +976,9 @@ ExecAppend(TupleTableSlot *slot,
} }
} }
/* ---------------- /******************
* Check the constraints of a tuple * Check the constraints of a tuple
* ---------------- ******************
*/ */
if (resultRelationDesc->rd_att->constr) if (resultRelationDesc->rd_att->constr)
@ -995,21 +995,21 @@ ExecAppend(TupleTableSlot *slot,
} }
} }
/* ---------------- /******************
* insert the tuple * insert the tuple
* ---------------- ******************
*/ */
newId = heap_insert(resultRelationDesc, /* relation desc */ newId = heap_insert(resultRelationDesc, /* relation desc */
tuple); /* heap tuple */ tuple); /* heap tuple */
IncrAppended(); IncrAppended();
/* ---------------- /******************
* process indices * process indices
* *
* Note: heap_insert adds a new tuple to a relation. As a side * Note: heap_insert adds a new tuple to a relation. As a side
* effect, the tupleid of the new tuple is placed in the new * effect, the tupleid of the new tuple is placed in the new
* tuple's t_ctid field. * tuple's t_ctid field.
* ---------------- ******************
*/ */
numIndices = resultRelationInfo->ri_NumIndices; numIndices = resultRelationInfo->ri_NumIndices;
if (numIndices > 0) if (numIndices > 0)
@ -1038,9 +1038,9 @@ ExecDelete(TupleTableSlot *slot,
RelationInfo *resultRelationInfo; RelationInfo *resultRelationInfo;
Relation resultRelationDesc; Relation resultRelationDesc;
/* ---------------- /******************
* get the result relation information * get the result relation information
* ---------------- ******************
*/ */
resultRelationInfo = estate->es_result_relation_info; resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc; resultRelationDesc = resultRelationInfo->ri_RelationDesc;
@ -1057,9 +1057,9 @@ ExecDelete(TupleTableSlot *slot,
return; return;
} }
/* ---------------- /******************
* delete the tuple * delete the tuple
* ---------------- ******************
*/ */
if (heap_delete(resultRelationDesc, /* relation desc */ if (heap_delete(resultRelationDesc, /* relation desc */
tupleid)) /* item pointer to tuple */ tupleid)) /* item pointer to tuple */
@ -1068,7 +1068,7 @@ ExecDelete(TupleTableSlot *slot,
IncrDeleted(); IncrDeleted();
(estate->es_processed)++; (estate->es_processed)++;
/* ---------------- /******************
* Note: Normally one would think that we have to * Note: Normally one would think that we have to
* delete index tuples associated with the * delete index tuples associated with the
* heap tuple now.. * heap tuple now..
@ -1077,7 +1077,7 @@ ExecDelete(TupleTableSlot *slot,
* because the vacuum daemon automatically * because the vacuum daemon automatically
* opens an index scan and deletes index tuples * opens an index scan and deletes index tuples
* when it finds deleted heap tuples. -cim 9/27/89 * when it finds deleted heap tuples. -cim 9/27/89
* ---------------- ******************
*/ */
/* AFTER ROW DELETE Triggers */ /* AFTER ROW DELETE Triggers */
@ -1109,9 +1109,9 @@ ExecReplace(TupleTableSlot *slot,
Relation resultRelationDesc; Relation resultRelationDesc;
int numIndices; int numIndices;
/* ---------------- /******************
* abort the operation if not running transactions * abort the operation if not running transactions
* ---------------- ******************
*/ */
if (IsBootstrapProcessingMode()) if (IsBootstrapProcessingMode())
{ {
@ -1119,25 +1119,25 @@ ExecReplace(TupleTableSlot *slot,
return; return;
} }
/* ---------------- /******************
* get the heap tuple out of the tuple table slot * get the heap tuple out of the tuple table slot
* ---------------- ******************
*/ */
tuple = slot->val; tuple = slot->val;
/* ---------------- /******************
* get the result relation information * get the result relation information
* ---------------- ******************
*/ */
resultRelationInfo = estate->es_result_relation_info; resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc; resultRelationDesc = resultRelationInfo->ri_RelationDesc;
/* ---------------- /******************
* have to add code to preform unique checking here. * have to add code to preform unique checking here.
* in the event of unique tuples, this becomes a deletion * in the event of unique tuples, this becomes a deletion
* of the original tuple affected by the replace. * of the original tuple affected by the replace.
* cim -12/1/89 * cim -12/1/89
* ---------------- ******************
*/ */
/* BEFORE ROW UPDATE Triggers */ /* BEFORE ROW UPDATE Triggers */
@ -1159,9 +1159,9 @@ ExecReplace(TupleTableSlot *slot,
} }
} }
/* ---------------- /******************
* Check the constraints of a tuple * Check the constraints of a tuple
* ---------------- ******************
*/ */
if (resultRelationDesc->rd_att->constr) if (resultRelationDesc->rd_att->constr)
@ -1178,13 +1178,13 @@ ExecReplace(TupleTableSlot *slot,
} }
} }
/* ---------------- /******************
* replace the heap tuple * replace the heap tuple
* *
* Don't want to continue if our heap_replace didn't actually * Don't want to continue if our heap_replace didn't actually
* do a replace. This would be the case if heap_replace * do a replace. This would be the case if heap_replace
* detected a non-functional update. -kw 12/30/93 * detected a non-functional update. -kw 12/30/93
* ---------------- ******************
*/ */
if (heap_replace(resultRelationDesc, /* relation desc */ if (heap_replace(resultRelationDesc, /* relation desc */
tupleid, /* item ptr of tuple to replace */ tupleid, /* item ptr of tuple to replace */
@ -1196,7 +1196,7 @@ ExecReplace(TupleTableSlot *slot,
IncrReplaced(); IncrReplaced();
(estate->es_processed)++; (estate->es_processed)++;
/* ---------------- /******************
* Note: instead of having to update the old index tuples * Note: instead of having to update the old index tuples
* associated with the heap tuple, all we do is form * associated with the heap tuple, all we do is form
* and insert new index tuples.. This is because * and insert new index tuples.. This is because
@ -1204,10 +1204,10 @@ ExecReplace(TupleTableSlot *slot,
* index tuple deletion is done automagically by * index tuple deletion is done automagically by
* the vaccuum deamon.. All we do is insert new * the vaccuum deamon.. All we do is insert new
* index tuples. -cim 9/27/89 * index tuples. -cim 9/27/89
* ---------------- ******************
*/ */
/* ---------------- /******************
* process indices * process indices
* *
* heap_replace updates a tuple in the base relation by invalidating * heap_replace updates a tuple in the base relation by invalidating
@ -1215,7 +1215,7 @@ ExecReplace(TupleTableSlot *slot,
* effect, the tupleid of the new tuple is placed in the new * effect, the tupleid of the new tuple is placed in the new
* tuple's t_ctid field. So we now insert index tuples using * tuple's t_ctid field. So we now insert index tuples using
* the new tupleid stored there. * the new tupleid stored there.
* ---------------- ******************
*/ */
numIndices = resultRelationInfo->ri_NumIndices; numIndices = resultRelationInfo->ri_NumIndices;

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

@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.36 1998/09/01 04:28:18 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.37 1998/09/25 13:38:31 thomas Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -53,9 +53,9 @@
#include "utils/memutils.h" #include "utils/memutils.h"
/* ---------------- /******************
* externs and constants * externs and constants
* ---------------- ******************
*/ */
/* /*
@ -84,15 +84,14 @@ static Datum ExecMakeFunctionResult(Node *node, List *arguments,
ExprContext *econtext, bool *isNull, bool *isDone); ExprContext *econtext, bool *isNull, bool *isDone);
static bool ExecQualClause(Node *clause, ExprContext *econtext); static bool ExecQualClause(Node *clause, ExprContext *econtext);
/* -------------------------------- /******************
* ExecEvalArrayRef * ExecEvalArrayRef
* *
* This function takes an ArrayRef and returns a Const Node if it * This function takes an ArrayRef and returns a Const Node if it
* is an array reference or returns the changed Array Node if it is * is an array reference or returns the changed Array Node if it is
* an array assignment. * an array assignment.
* *
* -------------------------------- ******************/
*/
static Datum static Datum
ExecEvalArrayRef(ArrayRef *arrayRef, ExecEvalArrayRef(ArrayRef *arrayRef,
ExprContext *econtext, ExprContext *econtext,
@ -234,9 +233,9 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
bool byval; bool byval;
int16 len; int16 len;
/* ---------------- /******************
* get the slot we want * get the slot we want
* ---------------- ******************
*/ */
switch (variable->varno) switch (variable->varno)
{ {
@ -254,9 +253,9 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
break; break;
} }
/* ---------------- /******************
* extract tuple information from the slot * extract tuple information from the slot
* ---------------- ******************
*/ */
heapTuple = slot->val; heapTuple = slot->val;
tuple_type = slot->ttc_tupleDescriptor; tuple_type = slot->ttc_tupleDescriptor;
@ -303,14 +302,14 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
tuple_type, /* tuple descriptor of tuple */ tuple_type, /* tuple descriptor of tuple */
isNull); /* return: is attribute null? */ isNull); /* return: is attribute null? */
/* ---------------- /******************
* return null if att is null * return null if att is null
* ---------------- ******************
*/ */
if (*isNull) if (*isNull)
return (Datum) NULL; return (Datum) NULL;
/* ---------------- /******************
* get length and type information.. * get length and type information..
* ??? what should we do about variable length attributes * ??? what should we do about variable length attributes
* - variable length attributes have their length stored * - variable length attributes have their length stored
@ -318,15 +317,15 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
* returned value.. If we can determine that the type * returned value.. If we can determine that the type
* is a variable length type, we can do the right thing. * is a variable length type, we can do the right thing.
* -cim 9/15/89 * -cim 9/15/89
* ---------------- ******************
*/ */
if (attnum < 0) if (attnum < 0)
{ {
/* ---------------- /******************
* If this is a pseudo-att, we get the type and fake the length. * If this is a pseudo-att, we get the type and fake the length.
* There ought to be a routine to return the real lengths, so * There ought to be a routine to return the real lengths, so
* we'll mark this one ... XXX -mao * we'll mark this one ... XXX -mao
* ---------------- ******************
*/ */
len = heap_sysattrlen(attnum); /* XXX see -mao above */ len = heap_sysattrlen(attnum); /* XXX see -mao above */
byval = heap_sysattrbyval(attnum); /* XXX see -mao above */ byval = heap_sysattrbyval(attnum); /* XXX see -mao above */
@ -491,7 +490,7 @@ ExecEvalParam(Param *expression, ExprContext *econtext, bool *isNull)
* ---------------------------------------------------------------- * ----------------------------------------------------------------
*/ */
/* ---------------- /******************
* GetAttributeByName * GetAttributeByName
* GetAttributeByNum * GetAttributeByNum
* *
@ -499,7 +498,7 @@ ExecEvalParam(Param *expression, ExprContext *econtext, bool *isNull)
* named attribute out of the tuple from the arg slot. User defined * named attribute out of the tuple from the arg slot. User defined
* C functions which take a tuple as an argument are expected * C functions which take a tuple as an argument are expected
* to use this. Ex: overpaid(EMP) might call GetAttributeByNum(). * to use this. Ex: overpaid(EMP) might call GetAttributeByNum().
* ---------------- ******************
*/ */
/* static but gets called from external functions */ /* static but gets called from external functions */
char * char *
@ -621,12 +620,12 @@ ExecEvalFuncArgs(FunctionCachePtr fcache,
i = 0; i = 0;
foreach(arg, argList) foreach(arg, argList)
{ {
/* ---------------- /******************
* evaluate the expression, in general functions cannot take * evaluate the expression, in general functions cannot take
* sets as arguments but we make an exception in the case of * sets as arguments but we make an exception in the case of
* nested dot expressions. We have to watch out for this case * nested dot expressions. We have to watch out for this case
* here. * here.
* ---------------- ******************
*/ */
argV[i] = (Datum) argV[i] = (Datum)
ExecEvalExpr((Node *) lfirst(arg), ExecEvalExpr((Node *) lfirst(arg),
@ -649,9 +648,9 @@ ExecEvalFuncArgs(FunctionCachePtr fcache,
} }
} }
/* ---------------- /******************
* ExecMakeFunctionResult * ExecMakeFunctionResult
* ---------------- ******************
*/ */
static Datum static Datum
ExecMakeFunctionResult(Node *node, ExecMakeFunctionResult(Node *node,
@ -684,12 +683,12 @@ ExecMakeFunctionResult(Node *node,
fcache = operNode->op_fcache; fcache = operNode->op_fcache;
} }
/* ---------------- /******************
* arguments is a list of expressions to evaluate * arguments is a list of expressions to evaluate
* before passing to the function manager. * before passing to the function manager.
* We collect the results of evaluating the expressions * We collect the results of evaluating the expressions
* into a datum array (argV) and pass this array to arrayFmgr() * into a datum array (argV) and pass this array to arrayFmgr()
* ---------------- ******************
*/ */
if (fcache->nargs != 0) if (fcache->nargs != 0)
{ {
@ -757,10 +756,10 @@ ExecMakeFunctionResult(Node *node,
} }
} }
/* ---------------- /******************
* now return the value gotten by calling the function manager, * now return the value gotten by calling the function manager,
* passing the function the evaluated parameter values. * passing the function the evaluated parameter values.
* ---------------- ******************
*/ */
if (fcache->language == SQLlanguageId) if (fcache->language == SQLlanguageId)
{ {
@ -858,14 +857,14 @@ ExecEvalOper(Expr *opClause, ExprContext *econtext, bool *isNull)
FunctionCachePtr fcache; FunctionCachePtr fcache;
bool isDone; bool isDone;
/* ---------------- /******************
* an opclause is a list (op args). (I think) * an opclause is a list (op args). (I think)
* *
* we extract the oid of the function associated with * we extract the oid of the function associated with
* the op and then pass the work onto ExecMakeFunctionResult * the op and then pass the work onto ExecMakeFunctionResult
* which evaluates the arguments and returns the result of * which evaluates the arguments and returns the result of
* calling the function on the evaluated arguments. * calling the function on the evaluated arguments.
* ---------------- ******************
*/ */
op = (Oper *) opClause->oper; op = (Oper *) opClause->oper;
argList = opClause->args; argList = opClause->args;
@ -881,10 +880,10 @@ ExecEvalOper(Expr *opClause, ExprContext *econtext, bool *isNull)
fcache = op->op_fcache; fcache = op->op_fcache;
} }
/* ----------- /******************
* call ExecMakeFunctionResult() with a dummy isDone that we ignore. * call ExecMakeFunctionResult() with a dummy isDone that we ignore.
* We don't have operator whose arguments are sets. * We don't have operator whose arguments are sets.
* ----------- ******************
*/ */
return return
ExecMakeFunctionResult((Node *) op, argList, econtext, isNull, &isDone); ExecMakeFunctionResult((Node *) op, argList, econtext, isNull, &isDone);
@ -905,7 +904,7 @@ ExecEvalFunc(Expr *funcClause,
List *argList; List *argList;
FunctionCachePtr fcache; FunctionCachePtr fcache;
/* ---------------- /******************
* an funcclause is a list (func args). (I think) * an funcclause is a list (func args). (I think)
* *
* we extract the oid of the function associated with * we extract the oid of the function associated with
@ -914,7 +913,7 @@ ExecEvalFunc(Expr *funcClause,
* calling the function on the evaluated arguments. * calling the function on the evaluated arguments.
* *
* this is nearly identical to the ExecEvalOper code. * this is nearly identical to the ExecEvalOper code.
* ---------------- ******************
*/ */
func = (Func *) funcClause->oper; func = (Func *) funcClause->oper;
argList = funcClause->args; argList = funcClause->args;
@ -959,25 +958,25 @@ ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull)
clause = lfirst(notclause->args); clause = lfirst(notclause->args);
/* ---------------- /******************
* We don't iterate over sets in the quals, so pass in an isDone * We don't iterate over sets in the quals, so pass in an isDone
* flag, but ignore it. * flag, but ignore it.
* ---------------- ******************
*/ */
expr_value = ExecEvalExpr(clause, econtext, isNull, &isDone); expr_value = ExecEvalExpr(clause, econtext, isNull, &isDone);
/* ---------------- /******************
* if the expression evaluates to null, then we just * if the expression evaluates to null, then we just
* cascade the null back to whoever called us. * cascade the null back to whoever called us.
* ---------------- ******************
*/ */
if (*isNull) if (*isNull)
return expr_value; return expr_value;
/* ---------------- /******************
* evaluation of 'not' is simple.. expr is false, then * evaluation of 'not' is simple.. expr is false, then
* return 'true' and vice versa. * return 'true' and vice versa.
* ---------------- ******************
*/ */
if (DatumGetInt32(expr_value) == 0) if (DatumGetInt32(expr_value) == 0)
return (Datum) true; return (Datum) true;
@ -1001,7 +1000,7 @@ ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
IsNull = false; IsNull = false;
clauses = orExpr->args; clauses = orExpr->args;
/* ---------------- /******************
* we use three valued logic functions here... * we use three valued logic functions here...
* we evaluate each of the clauses in turn, * we evaluate each of the clauses in turn,
* as soon as one is true we return that * as soon as one is true we return that
@ -1011,51 +1010,52 @@ ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
* should be false) with *isNull set to false else * should be false) with *isNull set to false else
* if none is true and at least one clause evaluated * if none is true and at least one clause evaluated
* to NULL we set *isNull flag to true - * to NULL we set *isNull flag to true -
* ---------------- ******************
*/ */
foreach(clause, clauses) foreach(clause, clauses)
{ {
/* ---------------- /******************
* We don't iterate over sets in the quals, so pass in an isDone * We don't iterate over sets in the quals, so pass in an isDone
* flag, but ignore it. * flag, but ignore it.
* ---------------- ******************
*/ */
const_value = ExecEvalExpr((Node *) lfirst(clause), const_value = ExecEvalExpr((Node *) lfirst(clause),
econtext, econtext,
isNull, isNull,
&isDone); &isDone);
/* ---------------- /******************
* if the expression evaluates to null, then we * if the expression evaluates to null, then we
* remember it in the local IsNull flag, if none of the * remember it in the local IsNull flag, if none of the
* clauses are true then we need to set *isNull * clauses are true then we need to set *isNull
* to true again. * to true again.
* ---------------- ******************
*/ */
if (*isNull) if (*isNull)
{ {
IsNull = *isNull; IsNull = *isNull;
/* /*************
* Many functions don't (or can't!) check is an argument NULL * Many functions don't (or can't!) check if an argument is NULL
* or NOT_NULL and may return TRUE (1) with *isNull TRUE * or NOT_NULL and may return TRUE (1) with *isNull TRUE
* (an_int4_column <> 1: int4ne returns TRUE for NULLs). Not * (an_int4_column <> 1: int4ne returns TRUE for NULLs).
* having time to fix function manager I want to fix OR: if we * Not having time to fix the function manager I want to fix OR:
* had 'x <> 1 OR x isnull' then TRUE, TRUE were returned by * if we had 'x <> 1 OR x isnull' then when x is NULL
* 'x <> 1' for NULL ... but ExecQualClause say that * TRUE was returned by the 'x <> 1' clause ...
* qualification *fails* if isnull is TRUE for all values * but ExecQualClause says that the qualification should *fail*
* returned by ExecEvalExpr. So, force this rule here: if * if isnull is TRUE for any value returned by ExecEvalExpr.
* isnull is TRUE then clause failed. Note: nullvalue() & * So, force this rule here:
* nonnullvalue() always set isnull to FALSE for NULLs. - * if isnull is TRUE then the clause failed.
* vadim 09/22/97 * Note: nullvalue() & nonnullvalue() always sets isnull to FALSE for NULLs.
*/ * - vadim 09/22/97
*************/
const_value = 0; const_value = 0;
} }
/* ---------------- /******************
* if we have a true result, then we return it. * if we have a true result, then we return it.
* ---------------- ******************
*/ */
if (DatumGetInt32(const_value) != 0) if (DatumGetInt32(const_value) != 0)
return const_value; return const_value;
@ -1083,41 +1083,41 @@ ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull)
clauses = andExpr->args; clauses = andExpr->args;
/* ---------------- /******************
* we evaluate each of the clauses in turn, * we evaluate each of the clauses in turn,
* as soon as one is false we return that * as soon as one is false we return that
* value. If none are false or NULL then we return * value. If none are false or NULL then we return
* the value of the last clause evaluated, which * the value of the last clause evaluated, which
* should be true. * should be true.
* ---------------- ******************
*/ */
foreach(clause, clauses) foreach(clause, clauses)
{ {
/* ---------------- /******************
* We don't iterate over sets in the quals, so pass in an isDone * We don't iterate over sets in the quals, so pass in an isDone
* flag, but ignore it. * flag, but ignore it.
* ---------------- ******************
*/ */
const_value = ExecEvalExpr((Node *) lfirst(clause), const_value = ExecEvalExpr((Node *) lfirst(clause),
econtext, econtext,
isNull, isNull,
&isDone); &isDone);
/* ---------------- /******************
* if the expression evaluates to null, then we * if the expression evaluates to null, then we
* remember it in IsNull, if none of the clauses after * remember it in IsNull, if none of the clauses after
* this evaluates to false we will have to set *isNull * this evaluates to false we will have to set *isNull
* to true again. * to true again.
* ---------------- ******************
*/ */
if (*isNull) if (*isNull)
IsNull = *isNull; IsNull = *isNull;
/* ---------------- /******************
* if we have a false result, then we return it, since the * if we have a false result, then we return it, since the
* conjunction must be false. * conjunction must be false.
* ---------------- ******************
*/ */
if (DatumGetInt32(const_value) == 0) if (DatumGetInt32(const_value) == 0)
return const_value; return const_value;
@ -1164,10 +1164,10 @@ ExecEvalExpr(Node *expression,
if (isDone) if (isDone)
*isDone = true; *isDone = true;
/* ---------------- /******************
* here we dispatch the work to the appropriate type * here we dispatch the work to the appropriate type
* of function given the type of our expression. * of function given the type of our expression.
* ---------------- ******************
*/ */
if (expression == NULL) if (expression == NULL)
{ {
@ -1281,19 +1281,19 @@ ExecQualClause(Node *clause, ExprContext *econtext)
expr_value = (Datum) expr_value = (Datum)
ExecEvalExpr(clause, econtext, &isNull, &isDone); ExecEvalExpr(clause, econtext, &isNull, &isDone);
/* ---------------- /******************
* this is interesting behaviour here. When a clause evaluates * this is interesting behaviour here. When a clause evaluates
* to null, then we consider this as passing the qualification. * to null, then we consider this as passing the qualification.
* it seems kind of like, if the qual is NULL, then there's no * it seems kind of like, if the qual is NULL, then there's no
* qual.. * qual..
* ---------------- ******************
*/ */
if (isNull) if (isNull)
return true; return true;
/* ---------------- /******************
* remember, we return true when the qualification fails.. * remember, we return true when the qualification fails..
* ---------------- ******************
*/ */
if (DatumGetInt32(expr_value) == 0) if (DatumGetInt32(expr_value) == 0)
return true; return true;
@ -1314,9 +1314,9 @@ ExecQual(List *qual, ExprContext *econtext)
List *clause; List *clause;
bool result; bool result;
/* ---------------- /******************
* debugging stuff * debugging stuff
* ---------------- ******************
*/ */
EV_printf("ExecQual: qual is "); EV_printf("ExecQual: qual is ");
EV_nodeDisplay(qual); EV_nodeDisplay(qual);
@ -1324,21 +1324,21 @@ ExecQual(List *qual, ExprContext *econtext)
IncrProcessed(); IncrProcessed();
/* ---------------- /******************
* return true immediately if no qual * return true immediately if no qual
* ---------------- ******************
*/ */
if (qual == NIL) if (qual == NIL)
return true; return true;
/* ---------------- /******************
* a "qual" is a list of clauses. To evaluate the * a "qual" is a list of clauses. To evaluate the
* qual, we evaluate each of the clauses in the list. * qual, we evaluate each of the clauses in the list.
* *
* ExecQualClause returns true when we know the qualification * ExecQualClause returns true when we know the qualification
* *failed* so we just pass each clause in qual to it until * *failed* so we just pass each clause in qual to it until
* we know the qual failed or there are no more clauses. * we know the qual failed or there are no more clauses.
* ---------------- ******************
*/ */
result = false; result = false;
@ -1349,11 +1349,11 @@ ExecQual(List *qual, ExprContext *econtext)
break; break;
} }
/* ---------------- /******************
* if result is true, then it means a clause failed so we * if result is true, then it means a clause failed so we
* return false. if result is false then it means no clause * return false. if result is false then it means no clause
* failed so we return true. * failed so we return true.
* ---------------- ******************
*/ */
if (result == true) if (result == true)
return false; return false;
@ -1409,23 +1409,23 @@ ExecTargetList(List *targetlist,
HeapTuple newTuple; HeapTuple newTuple;
bool isNull; bool isNull;
/* ---------------- /******************
* debugging stuff * debugging stuff
* ---------------- ******************
*/ */
EV_printf("ExecTargetList: tl is "); EV_printf("ExecTargetList: tl is ");
EV_nodeDisplay(targetlist); EV_nodeDisplay(targetlist);
EV_printf("\n"); EV_printf("\n");
/* ---------------- /******************
* Return a dummy tuple if the targetlist is empty . * Return a dummy tuple if the targetlist is empty .
* the dummy tuple is necessary to differentiate * the dummy tuple is necessary to differentiate
* between passing and failing the qualification. * between passing and failing the qualification.
* ---------------- ******************
*/ */
if (targetlist == NIL) if (targetlist == NIL)
{ {
/* ---------------- /******************
* I now think that the only time this makes * I now think that the only time this makes
* any sence is when we run a delete query. Then * any sence is when we run a delete query. Then
* we need to return something other than nil * we need to return something other than nil
@ -1439,18 +1439,18 @@ ExecTargetList(List *targetlist,
* is this a new phenomenon? it might cause bogus behavior * is this a new phenomenon? it might cause bogus behavior
* if we try to free this tuple later!! I put a hook in * if we try to free this tuple later!! I put a hook in
* ExecProject to watch out for this case -mer 24 Aug 1992 * ExecProject to watch out for this case -mer 24 Aug 1992
* ---------------- ******************
*/ */
CXT1_printf("ExecTargetList: context is %d\n", CurrentMemoryContext); CXT1_printf("ExecTargetList: context is %d\n", CurrentMemoryContext);
*isDone = true; *isDone = true;
return (HeapTuple) true; return (HeapTuple) true;
} }
/* ---------------- /******************
* allocate an array of char's to hold the "null" information * allocate an array of char's to hold the "null" information
* only if we have a really large targetlist. otherwise we use * only if we have a really large targetlist. otherwise we use
* the stack. * the stack.
* ---------------- ******************
*/ */
if (nodomains > 64) if (nodomains > 64)
{ {
@ -1463,23 +1463,23 @@ ExecTargetList(List *targetlist,
fjIsNull = &fjNullArray[0]; fjIsNull = &fjNullArray[0];
} }
/* ---------------- /******************
* evaluate all the expressions in the target list * evaluate all the expressions in the target list
* ---------------- ******************
*/ */
EV_printf("ExecTargetList: setting target list values\n"); EV_printf("ExecTargetList: setting target list values\n");
*isDone = true; *isDone = true;
foreach(tl, targetlist) foreach(tl, targetlist)
{ {
/* ---------------- /******************
* remember, a target list is a list of lists: * remember, a target list is a list of lists:
* *
* ((<resdom | fjoin> expr) (<resdom | fjoin> expr) ...) * ((<resdom | fjoin> expr) (<resdom | fjoin> expr) ...)
* *
* tl is a pointer to successive cdr's of the targetlist * tl is a pointer to successive cdr's of the targetlist
* tle is a pointer to the target list entry in tl * tle is a pointer to the target list entry in tl
* ---------------- ******************
*/ */
tle = lfirst(tl); tle = lfirst(tl);
@ -1553,16 +1553,16 @@ ExecTargetList(List *targetlist,
} }
} }
/* ---------------- /******************
* form the new result tuple (in the "normal" context) * form the new result tuple (in the "normal" context)
* ---------------- ******************
*/ */
newTuple = (HeapTuple) newTuple = (HeapTuple)
heap_formtuple(targettype, values, null_head); heap_formtuple(targettype, values, null_head);
/* ---------------- /******************
* free the nulls array if we allocated one.. * free the nulls array if we allocated one..
* ---------------- ******************
*/ */
if (nodomains > 64) if (nodomains > 64)
pfree(null_head); pfree(null_head);
@ -1595,16 +1595,16 @@ ExecProject(ProjectionInfo *projInfo, bool *isDone)
ExprContext *econtext; ExprContext *econtext;
HeapTuple newTuple; HeapTuple newTuple;
/* ---------------- /******************
* sanity checks * sanity checks
* ---------------- ******************
*/ */
if (projInfo == NULL) if (projInfo == NULL)
return (TupleTableSlot *) NULL; return (TupleTableSlot *) NULL;
/* ---------------- /******************
* get the projection info we want * get the projection info we want
* ---------------- ******************
*/ */
slot = projInfo->pi_slot; slot = projInfo->pi_slot;
targetlist = projInfo->pi_targetlist; targetlist = projInfo->pi_targetlist;
@ -1620,9 +1620,9 @@ ExecProject(ProjectionInfo *projInfo, bool *isDone)
return (TupleTableSlot *) NULL; return (TupleTableSlot *) NULL;
} }
/* ---------------- /******************
* form a new (result) tuple * form a new (result) tuple
* ---------------- ******************
*/ */
newTuple = ExecTargetList(targetlist, newTuple = ExecTargetList(targetlist,
len, len,
@ -1631,13 +1631,13 @@ ExecProject(ProjectionInfo *projInfo, bool *isDone)
econtext, econtext,
isDone); isDone);
/* ---------------- /******************
* store the tuple in the projection slot and return the slot. * store the tuple in the projection slot and return the slot.
* *
* If there's no projection target list we don't want to pfree * If there's no projection target list we don't want to pfree
* the bogus tuple that ExecTargetList passes back to us. * the bogus tuple that ExecTargetList passes back to us.
* -mer 24 Aug 1992 * -mer 24 Aug 1992
* ---------------- ******************
*/ */
return (TupleTableSlot *) return (TupleTableSlot *)
ExecStoreTuple(newTuple,/* tuple to store */ ExecStoreTuple(newTuple,/* tuple to store */

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

@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.14 1998/09/01 04:28:37 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.15 1998/09/25 13:38:32 thomas Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -29,6 +29,7 @@
#include "executor/nodeSeqscan.h" #include "executor/nodeSeqscan.h"
#include "access/heapam.h" #include "access/heapam.h"
#include "parser/parsetree.h" #include "parser/parsetree.h"
#include "nodes/print.h"
static Oid InitScanRelation(SeqScan *node, EState *estate, static Oid InitScanRelation(SeqScan *node, EState *estate,
CommonScanState *scanstate, Plan *outerPlan); CommonScanState *scanstate, Plan *outerPlan);