Modify comment blocks to insulate from pgindent.
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
CommandDest dest;
void (*destination) ();
- /* ----------------
+ /******************
* sanity checks
- * ----------------
+ ******************
*/
Assert(queryDesc != NULL);
- /* ----------------
+ /******************
* extract information from the query descriptor
* and the query feature.
- * ----------------
+ ******************
*/
operation = queryDesc->operation;
parseTree = queryDesc->parsetree;
destination);
break;
- /* ----------------
+ /******************
* retrieve next n "backward" tuples
- * ----------------
+ ******************
*/
case EXEC_BACK:
result = ExecutePlan(estate,
destination);
break;
- /* ----------------
+ /******************
* return one tuple but don't "retrieve" it.
* (this is used by the rule manager..) -cim 9/14/89
- * ----------------
+ ******************
*/
case EXEC_RETONE:
result = ExecutePlan(estate,
List *targetList;
int len;
- /* ----------------
+ /******************
* get information from query descriptor
- * ----------------
+ ******************
*/
rangeTable = parseTree->rtable;
resultRelation = parseTree->resultRelation;
- /* ----------------
+ /******************
* initialize the node's execution state
- * ----------------
+ ******************
*/
estate->es_range_table = rangeTable;
- /* ----------------
+ /******************
* initialize the BaseId counter so node base_id's
* are assigned correctly. Someday baseid's will have to
* be stored someplace other than estate because they
* should be unique per query planned.
- * ----------------
+ ******************
*/
estate->es_BaseId = 1;
- /* ----------------
+ /******************
* initialize result relation stuff
- * ----------------
+ ******************
*/
if (resultRelation != 0 && operation != CMD_SELECT)
{
- /* ----------------
+ /******************
* if we have a result relation, open it and
* initialize the result relation info stuff.
- * ----------------
+ ******************
*/
RelationInfo *resultRelationInfo;
Index resultRelationIndex;
resultRelationInfo->ri_IndexRelationDescs = NULL;
resultRelationInfo->ri_IndexRelationInfo = NULL;
- /* ----------------
+ /******************
* open indices on result relation and save descriptors
* in the result relation information..
- * ----------------
+ ******************
*/
ExecOpenIndices(resultRelationOid, resultRelationInfo);
}
else
{
- /* ----------------
+ /******************
* if no result relation, then set state appropriately
- * ----------------
+ ******************
*/
estate->es_result_relation_info = NULL;
}
ExecCheckPerms(operation, resultRelation, rangeTable, parseTree);
#endif
- /* ----------------
+ /******************
* initialize the executor "tuple" table.
- * ----------------
+ ******************
*/
{
int nSlots = ExecCountSlotsNode(plan);
estate->es_tupleTable = tupleTable;
}
- /* ----------------
+ /******************
* initialize the private state information for
* all the nodes in the query tree. This opens
* files, allocates storage and leaves us ready
* to start processing tuples..
- * ----------------
+ ******************
*/
ExecInitNode(plan, estate, NULL);
- /* ----------------
+ /******************
* get the tuple descriptor describing the type
* of tuples to return.. (this is especially important
* if we are creating a relation with "retrieve into")
- * ----------------
+ ******************
*/
tupType = ExecGetTupType(plan); /* tuple descriptor */
targetList = plan->targetlist;
len = ExecTargetListLength(targetList); /* number of attributes */
- /* ----------------
+ /******************
* now that we have the target list, initialize the junk filter
* if this is a REPLACE or a DELETE query.
* We also init the junk filter if this is an append query
* (there might be some rule lock info there...)
* NOTE: in the future we might want to initialize the junk
* filter for all queries.
- * ----------------
+ ******************
* ORDER/GROUP BY have an identifier missing from the target.
*/
estate->es_junkFilter = NULL;
}
- /* ----------------
+ /******************
* initialize the "into" relation
- * ----------------
+ ******************
*/
intoRelationDesc = (Relation) NULL;
*/
if (parseTree->into != NULL)
{
- /* ----------------
+ /******************
* create the "into" relation
- * ----------------
+ ******************
*/
intoName = parseTree->into;
FreeTupleDesc(tupdesc);
- /* ----------------
+ /******************
* XXX rather than having to call setheapoverride(true)
* and then back to false, we should change the
* arguments to heap_open() instead..
- * ----------------
+ ******************
*/
setheapoverride(true);
RelationInfo *resultRelationInfo;
Relation intoRelationDesc;
- /* ----------------
+ /******************
* get information from state
- * ----------------
+ ******************
*/
resultRelationInfo = estate->es_result_relation_info;
intoRelationDesc = estate->es_into_relation_descriptor;
- /* ----------------
+ /******************
* shut down the query
- * ----------------
+ ******************
*/
ExecEndNode(plan, plan);
- /* ----------------
+ /******************
* destroy the executor "tuple" table.
- * ----------------
+ ******************
*/
{
TupleTable tupleTable = (TupleTable) estate->es_tupleTable;
estate->es_tupleTable = NULL;
}
- /* ----------------
+ /******************
* close the result relations if necessary
- * ----------------
+ ******************
*/
if (resultRelationInfo != NULL)
{
resultRelationDesc = resultRelationInfo->ri_RelationDesc;
heap_close(resultRelationDesc);
- /* ----------------
+ /******************
* close indices on the result relation
- * ----------------
+ ******************
*/
ExecCloseIndices(resultRelationInfo);
}
- /* ----------------
+ /******************
* close the "into" relation if necessary
- * ----------------
+ ******************
*/
if (intoRelationDesc != NULL)
heap_close(intoRelationDesc);
int current_tuple_count;
TupleTableSlot *result;
- /* ----------------
+ /******************
* initialize local variables
- * ----------------
+ ******************
*/
slot = NULL;
current_tuple_count = 0;
result = NULL;
- /* ----------------
+ /******************
* Set the direction.
- * ----------------
+ ******************
*/
estate->es_direction = direction;
- /* ----------------
+ /******************
* Loop until we've processed the proper number
* of tuples from the plan..
- * ----------------
+ ******************
*/
for (;;)
{
if (operation != CMD_NOTIFY)
{
- /* ----------------
+ /******************
* Execute the plan and obtain a tuple
- * ----------------
+ ******************
*/
/* at the top level, the parent of a plan (2nd arg) is itself */
slot = ExecProcNode(plan, plan);
- /* ----------------
+ /******************
* if the tuple is null, then we assume
* there is nothing more to process so
* we just return null...
- * ----------------
+ ******************
*/
if (TupIsNull(slot))
{
}
}
- /* ----------------
+ /******************
* if we have a junk filter, then project a new
* tuple with the junk removed.
*
* Store this new "clean" tuple in the place of the
* 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)
{
HeapTuple newTuple;
bool isNull;
- /* ---------------
+ /******************
* extract the 'ctid' junk attribute.
- * ---------------
+ ******************
*/
if (operation == CMD_UPDATE || operation == CMD_DELETE)
{
tupleid = &tuple_ctid;
}
- /* ---------------
+ /******************
* Finally create a new "clean" tuple with all junk attributes
* removed
- * ---------------
+ ******************
*/
newTuple = ExecRemoveJunk(junkfilter, slot);
true); /* tuple should be pfreed */
} /* if (junkfilter... */
- /* ----------------
+ /******************
* now that we have a tuple, do the appropriate thing
* with it.. either return it to the user, add
* it to a relation someplace, delete it from a
* relation, or modify some of it's attributes.
- * ----------------
+ ******************
*/
switch (operation)
result = NULL;
break;
}
- /* ----------------
+ /******************
* check our tuple count.. if we've returned the
* proper number then return, else loop again and
* process more tuples..
- * ----------------
+ ******************
*/
current_tuple_count += 1;
if (numberTuples == current_tuple_count)
break;
}
- /* ----------------
+ /******************
* here, result is either a slot containing a tuple in the case
* of a RETRIEVE or NULL otherwise.
- * ----------------
+ ******************
*/
return result;
}
HeapTuple tuple;
TupleDesc attrtype;
- /* ----------------
+ /******************
* get the heap tuple out of the tuple table slot
- * ----------------
+ ******************
*/
tuple = slot->val;
attrtype = slot->ttc_tupleDescriptor;
- /* ----------------
+ /******************
* insert the tuple into the "into relation"
- * ----------------
+ ******************
*/
if (estate->es_into_relation_descriptor != NULL)
{
IncrAppended();
}
- /* ----------------
+ /******************
* send the tuple to the front end (or the screen)
- * ----------------
+ ******************
*/
(*printfunc) (tuple, attrtype);
IncrRetrieved();
int numIndices;
Oid newId;
- /* ----------------
+ /******************
* get the heap tuple out of the tuple table slot
- * ----------------
+ ******************
*/
tuple = slot->val;
- /* ----------------
+ /******************
* get information on the result relation
- * ----------------
+ ******************
*/
resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc;
- /* ----------------
+ /******************
* have to add code to preform unique checking here.
* cim -12/1/89
- * ----------------
+ ******************
*/
/* BEFORE ROW INSERT Triggers */
}
}
- /* ----------------
+ /******************
* Check the constraints of a tuple
- * ----------------
+ ******************
*/
if (resultRelationDesc->rd_att->constr)
}
}
- /* ----------------
+ /******************
* insert the tuple
- * ----------------
+ ******************
*/
newId = heap_insert(resultRelationDesc, /* relation desc */
tuple); /* heap tuple */
IncrAppended();
- /* ----------------
+ /******************
* process indices
*
* 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
* tuple's t_ctid field.
- * ----------------
+ ******************
*/
numIndices = resultRelationInfo->ri_NumIndices;
if (numIndices > 0)
RelationInfo *resultRelationInfo;
Relation resultRelationDesc;
- /* ----------------
+ /******************
* get the result relation information
- * ----------------
+ ******************
*/
resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc;
return;
}
- /* ----------------
+ /******************
* delete the tuple
- * ----------------
+ ******************
*/
if (heap_delete(resultRelationDesc, /* relation desc */
tupleid)) /* item pointer to tuple */
IncrDeleted();
(estate->es_processed)++;
- /* ----------------
+ /******************
* Note: Normally one would think that we have to
* delete index tuples associated with the
* heap tuple now..
* because the vacuum daemon automatically
* opens an index scan and deletes index tuples
* when it finds deleted heap tuples. -cim 9/27/89
- * ----------------
+ ******************
*/
/* AFTER ROW DELETE Triggers */
Relation resultRelationDesc;
int numIndices;
- /* ----------------
+ /******************
* abort the operation if not running transactions
- * ----------------
+ ******************
*/
if (IsBootstrapProcessingMode())
{
return;
}
- /* ----------------
+ /******************
* get the heap tuple out of the tuple table slot
- * ----------------
+ ******************
*/
tuple = slot->val;
- /* ----------------
+ /******************
* get the result relation information
- * ----------------
+ ******************
*/
resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc;
- /* ----------------
+ /******************
* have to add code to preform unique checking here.
* in the event of unique tuples, this becomes a deletion
* of the original tuple affected by the replace.
* cim -12/1/89
- * ----------------
+ ******************
*/
/* BEFORE ROW UPDATE Triggers */
}
}
- /* ----------------
+ /******************
* Check the constraints of a tuple
- * ----------------
+ ******************
*/
if (resultRelationDesc->rd_att->constr)
}
}
- /* ----------------
+ /******************
* replace the heap tuple
*
* Don't want to continue if our heap_replace didn't actually
* do a replace. This would be the case if heap_replace
* detected a non-functional update. -kw 12/30/93
- * ----------------
+ ******************
*/
if (heap_replace(resultRelationDesc, /* relation desc */
tupleid, /* item ptr of tuple to replace */
IncrReplaced();
(estate->es_processed)++;
- /* ----------------
+ /******************
* Note: instead of having to update the old index tuples
* associated with the heap tuple, all we do is form
* and insert new index tuples.. This is because
* index tuple deletion is done automagically by
* the vaccuum deamon.. All we do is insert new
* index tuples. -cim 9/27/89
- * ----------------
+ ******************
*/
- /* ----------------
+ /******************
* process indices
*
* heap_replace updates a tuple in the base relation by invalidating
* effect, the tupleid of the new tuple is placed in the new
* tuple's t_ctid field. So we now insert index tuples using
* the new tupleid stored there.
- * ----------------
+ ******************
*/
numIndices = resultRelationInfo->ri_NumIndices;
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
#include "utils/memutils.h"
-/* ----------------
+/******************
* externs and constants
- * ----------------
+ ******************
*/
/*
ExprContext *econtext, bool *isNull, bool *isDone);
static bool ExecQualClause(Node *clause, ExprContext *econtext);
-/* --------------------------------
+/******************
* ExecEvalArrayRef
*
* 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
* an array assignment.
*
- * --------------------------------
- */
+ ******************/
static Datum
ExecEvalArrayRef(ArrayRef *arrayRef,
ExprContext *econtext,
bool byval;
int16 len;
- /* ----------------
+ /******************
* get the slot we want
- * ----------------
+ ******************
*/
switch (variable->varno)
{
break;
}
- /* ----------------
+ /******************
* extract tuple information from the slot
- * ----------------
+ ******************
*/
heapTuple = slot->val;
tuple_type = slot->ttc_tupleDescriptor;
tuple_type, /* tuple descriptor of tuple */
isNull); /* return: is attribute null? */
- /* ----------------
+ /******************
* return null if att is null
- * ----------------
+ ******************
*/
if (*isNull)
return (Datum) NULL;
- /* ----------------
+ /******************
* get length and type information..
* ??? what should we do about variable length attributes
* - variable length attributes have their length stored
* returned value.. If we can determine that the type
* is a variable length type, we can do the right thing.
* -cim 9/15/89
- * ----------------
+ ******************
*/
if (attnum < 0)
{
- /* ----------------
+ /******************
* 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
* we'll mark this one ... XXX -mao
- * ----------------
+ ******************
*/
len = heap_sysattrlen(attnum); /* XXX see -mao above */
byval = heap_sysattrbyval(attnum); /* XXX see -mao above */
* ----------------------------------------------------------------
*/
-/* ----------------
+/******************
* GetAttributeByName
* GetAttributeByNum
*
* named attribute out of the tuple from the arg slot. User defined
* C functions which take a tuple as an argument are expected
* to use this. Ex: overpaid(EMP) might call GetAttributeByNum().
- * ----------------
+ ******************
*/
/* static but gets called from external functions */
char *
i = 0;
foreach(arg, argList)
{
- /* ----------------
+ /******************
* evaluate the expression, in general functions cannot take
* sets as arguments but we make an exception in the case of
* nested dot expressions. We have to watch out for this case
* here.
- * ----------------
+ ******************
*/
argV[i] = (Datum)
ExecEvalExpr((Node *) lfirst(arg),
}
}
-/* ----------------
+/******************
* ExecMakeFunctionResult
- * ----------------
+ ******************
*/
static Datum
ExecMakeFunctionResult(Node *node,
fcache = operNode->op_fcache;
}
- /* ----------------
+ /******************
* arguments is a list of expressions to evaluate
* before passing to the function manager.
* We collect the results of evaluating the expressions
* into a datum array (argV) and pass this array to arrayFmgr()
- * ----------------
+ ******************
*/
if (fcache->nargs != 0)
{
}
}
- /* ----------------
+ /******************
* now return the value gotten by calling the function manager,
* passing the function the evaluated parameter values.
- * ----------------
+ ******************
*/
if (fcache->language == SQLlanguageId)
{
FunctionCachePtr fcache;
bool isDone;
- /* ----------------
+ /******************
* an opclause is a list (op args). (I think)
*
* we extract the oid of the function associated with
* the op and then pass the work onto ExecMakeFunctionResult
* which evaluates the arguments and returns the result of
* calling the function on the evaluated arguments.
- * ----------------
+ ******************
*/
op = (Oper *) opClause->oper;
argList = opClause->args;
fcache = op->op_fcache;
}
- /* -----------
+ /******************
* call ExecMakeFunctionResult() with a dummy isDone that we ignore.
* We don't have operator whose arguments are sets.
- * -----------
+ ******************
*/
return
ExecMakeFunctionResult((Node *) op, argList, econtext, isNull, &isDone);
List *argList;
FunctionCachePtr fcache;
- /* ----------------
+ /******************
* an funcclause is a list (func args). (I think)
*
* we extract the oid of the function associated with
* calling the function on the evaluated arguments.
*
* this is nearly identical to the ExecEvalOper code.
- * ----------------
+ ******************
*/
func = (Func *) funcClause->oper;
argList = funcClause->args;
clause = lfirst(notclause->args);
- /* ----------------
+ /******************
* We don't iterate over sets in the quals, so pass in an isDone
* flag, but ignore it.
- * ----------------
+ ******************
*/
expr_value = ExecEvalExpr(clause, econtext, isNull, &isDone);
- /* ----------------
+ /******************
* if the expression evaluates to null, then we just
* cascade the null back to whoever called us.
- * ----------------
+ ******************
*/
if (*isNull)
return expr_value;
- /* ----------------
+ /******************
* evaluation of 'not' is simple.. expr is false, then
* return 'true' and vice versa.
- * ----------------
+ ******************
*/
if (DatumGetInt32(expr_value) == 0)
return (Datum) true;
IsNull = false;
clauses = orExpr->args;
- /* ----------------
+ /******************
* we use three valued logic functions here...
* we evaluate each of the clauses in turn,
* as soon as one is true we return that
* should be false) with *isNull set to false else
* if none is true and at least one clause evaluated
* to NULL we set *isNull flag to true -
- * ----------------
+ ******************
*/
foreach(clause, clauses)
{
- /* ----------------
+ /******************
* We don't iterate over sets in the quals, so pass in an isDone
* flag, but ignore it.
- * ----------------
+ ******************
*/
const_value = ExecEvalExpr((Node *) lfirst(clause),
econtext,
isNull,
&isDone);
- /* ----------------
+ /******************
* if the expression evaluates to null, then we
* remember it in the local IsNull flag, if none of the
* clauses are true then we need to set *isNull
* to true again.
- * ----------------
+ ******************
*/
if (*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
- * (an_int4_column <> 1: int4ne returns TRUE for NULLs). Not
- * having time to fix function manager I want to fix OR: if we
- * had 'x <> 1 OR x isnull' then TRUE, TRUE were returned by
- * 'x <> 1' for NULL ... but ExecQualClause say that
- * qualification *fails* if isnull is TRUE for all values
- * returned by ExecEvalExpr. So, force this rule here: if
- * isnull is TRUE then clause failed. Note: nullvalue() &
- * nonnullvalue() always set isnull to FALSE for NULLs. -
- * vadim 09/22/97
- */
+ * (an_int4_column <> 1: int4ne returns TRUE for NULLs).
+ * Not having time to fix the function manager I want to fix OR:
+ * if we had 'x <> 1 OR x isnull' then when x is NULL
+ * TRUE was returned by the 'x <> 1' clause ...
+ * but ExecQualClause says that the qualification should *fail*
+ * if isnull is TRUE for any value returned by ExecEvalExpr.
+ * So, force this rule here:
+ * if isnull is TRUE then the clause failed.
+ * Note: nullvalue() & nonnullvalue() always sets isnull to FALSE for NULLs.
+ * - vadim 09/22/97
+ *************/
const_value = 0;
}
- /* ----------------
+ /******************
* if we have a true result, then we return it.
- * ----------------
+ ******************
*/
if (DatumGetInt32(const_value) != 0)
return const_value;
clauses = andExpr->args;
- /* ----------------
+ /******************
* we evaluate each of the clauses in turn,
* as soon as one is false we return that
* value. If none are false or NULL then we return
* the value of the last clause evaluated, which
* should be true.
- * ----------------
+ ******************
*/
foreach(clause, clauses)
{
- /* ----------------
+ /******************
* We don't iterate over sets in the quals, so pass in an isDone
* flag, but ignore it.
- * ----------------
+ ******************
*/
const_value = ExecEvalExpr((Node *) lfirst(clause),
econtext,
isNull,
&isDone);
- /* ----------------
+ /******************
* if the expression evaluates to null, then we
* remember it in IsNull, if none of the clauses after
* this evaluates to false we will have to set *isNull
* to true again.
- * ----------------
+ ******************
*/
if (*isNull)
IsNull = *isNull;
- /* ----------------
+ /******************
* if we have a false result, then we return it, since the
* conjunction must be false.
- * ----------------
+ ******************
*/
if (DatumGetInt32(const_value) == 0)
return const_value;
if (isDone)
*isDone = true;
- /* ----------------
+ /******************
* here we dispatch the work to the appropriate type
* of function given the type of our expression.
- * ----------------
+ ******************
*/
if (expression == NULL)
{
expr_value = (Datum)
ExecEvalExpr(clause, econtext, &isNull, &isDone);
- /* ----------------
+ /******************
* this is interesting behaviour here. When a clause evaluates
* to null, then we consider this as passing the qualification.
* it seems kind of like, if the qual is NULL, then there's no
* qual..
- * ----------------
+ ******************
*/
if (isNull)
return true;
- /* ----------------
+ /******************
* remember, we return true when the qualification fails..
- * ----------------
+ ******************
*/
if (DatumGetInt32(expr_value) == 0)
return true;
List *clause;
bool result;
- /* ----------------
+ /******************
* debugging stuff
- * ----------------
+ ******************
*/
EV_printf("ExecQual: qual is ");
EV_nodeDisplay(qual);
IncrProcessed();
- /* ----------------
+ /******************
* return true immediately if no qual
- * ----------------
+ ******************
*/
if (qual == NIL)
return true;
- /* ----------------
+ /******************
* a "qual" is a list of clauses. To evaluate the
* qual, we evaluate each of the clauses in the list.
*
* ExecQualClause returns true when we know the qualification
* *failed* so we just pass each clause in qual to it until
* we know the qual failed or there are no more clauses.
- * ----------------
+ ******************
*/
result = false;
break;
}
- /* ----------------
+ /******************
* if result is true, then it means a clause failed so we
* return false. if result is false then it means no clause
* failed so we return true.
- * ----------------
+ ******************
*/
if (result == true)
return false;
HeapTuple newTuple;
bool isNull;
- /* ----------------
+ /******************
* debugging stuff
- * ----------------
+ ******************
*/
EV_printf("ExecTargetList: tl is ");
EV_nodeDisplay(targetlist);
EV_printf("\n");
- /* ----------------
+ /******************
* Return a dummy tuple if the targetlist is empty .
* the dummy tuple is necessary to differentiate
* between passing and failing the qualification.
- * ----------------
+ ******************
*/
if (targetlist == NIL)
{
- /* ----------------
+ /******************
* I now think that the only time this makes
* any sence is when we run a delete query. Then
* we need to return something other than nil
* is this a new phenomenon? it might cause bogus behavior
* if we try to free this tuple later!! I put a hook in
* ExecProject to watch out for this case -mer 24 Aug 1992
- * ----------------
+ ******************
*/
CXT1_printf("ExecTargetList: context is %d\n", CurrentMemoryContext);
*isDone = true;
return (HeapTuple) true;
}
- /* ----------------
+ /******************
* allocate an array of char's to hold the "null" information
* only if we have a really large targetlist. otherwise we use
* the stack.
- * ----------------
+ ******************
*/
if (nodomains > 64)
{
fjIsNull = &fjNullArray[0];
}
- /* ----------------
+ /******************
* evaluate all the expressions in the target list
- * ----------------
+ ******************
*/
EV_printf("ExecTargetList: setting target list values\n");
*isDone = true;
foreach(tl, targetlist)
{
- /* ----------------
+ /******************
* remember, a target list is a list of lists:
*
* (( expr) ( expr) ...)
*
* tl is a pointer to successive cdr's of the targetlist
* tle is a pointer to the target list entry in tl
- * ----------------
+ ******************
*/
tle = lfirst(tl);
}
}
- /* ----------------
+ /******************
* form the new result tuple (in the "normal" context)
- * ----------------
+ ******************
*/
newTuple = (HeapTuple)
heap_formtuple(targettype, values, null_head);
- /* ----------------
+ /******************
* free the nulls array if we allocated one..
- * ----------------
+ ******************
*/
if (nodomains > 64)
pfree(null_head);
ExprContext *econtext;
HeapTuple newTuple;
- /* ----------------
+ /******************
* sanity checks
- * ----------------
+ ******************
*/
if (projInfo == NULL)
return (TupleTableSlot *) NULL;
- /* ----------------
+ /******************
* get the projection info we want
- * ----------------
+ ******************
*/
slot = projInfo->pi_slot;
targetlist = projInfo->pi_targetlist;
return (TupleTableSlot *) NULL;
}
- /* ----------------
+ /******************
* form a new (result) tuple
- * ----------------
+ ******************
*/
newTuple = ExecTargetList(targetlist,
len,
econtext,
isDone);
- /* ----------------
+ /******************
* store the tuple in the projection slot and return the slot.
*
* If there's no projection target list we don't want to pfree
* the bogus tuple that ExecTargetList passes back to us.
* -mer 24 Aug 1992
- * ----------------
+ ******************
*/
return (TupleTableSlot *)
ExecStoreTuple(newTuple,/* tuple to store */
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
#include "executor/nodeSeqscan.h"
#include "access/heapam.h"
#include "parser/parsetree.h"
+#include "nodes/print.h"
static Oid InitScanRelation(SeqScan *node, EState *estate,
CommonScanState *scanstate, Plan *outerPlan);
projects / postgresql.git / commitdiff