database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-04-22 23:02:54 +03:00
Code

comment cleanup.

Browse Source
This commit is contained in:
Bruce Momjian 1999-02-22 19:40:10 +00:00
parent 01ec673cba
commit 7fe29ecefc
3 changed files with 191 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,7 +26,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.78 1999/02/21 03:48:36 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.79 1999/02/22 19:40:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -204,16 +204,14 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
int offset = 0;
int count = 0;
/******************
/*
* sanity checks
******************
*/
Assert(queryDesc != NULL);
/******************
/*
* extract information from the query descriptor
* and the query feature.
******************
*/
operation = queryDesc->operation;
plan = queryDesc->plantree;
@ -222,18 +220,16 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
estate->es_processed = 0;
estate->es_lastoid = InvalidOid;
/******************
/*
* FIXME: the dest setup function ought to be handed the tuple desc
* for the tuples to be output, but I'm not quite sure how to get that
* info at this point. For now, passing NULL is OK because no existing
* dest setup function actually uses the pointer.
******************
*/
(*destfunc->setup) (destfunc, (TupleDesc) NULL);
/******************
/*
* if given get the offset of the LIMIT clause
******************
*/
if (limoffset != NULL)
{
@ -276,9 +272,8 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
elog(ERROR, "limit offset cannot be negative");
}
/******************
/*
* if given get the count of the LIMIT clause
******************
*/
if (limcount != NULL)
{
@ -343,9 +338,8 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
destfunc);
break;
/******************
/*
* retrieve next n "backward" tuples
******************
*/
case EXEC_BACK:
result = ExecutePlan(estate,
@ -357,10 +351,9 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
destfunc);
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,
@ -561,9 +554,8 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
List *targetList;
int len;
/******************
/*
* get information from query descriptor
******************
*/
rangeTable = parseTree->rtable;
resultRelation = parseTree->resultRelation;
@ -572,32 +564,28 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
ExecCheckPerms(operation, resultRelation, rangeTable, parseTree);
#endif
/******************
/*
* 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;
@ -623,10 +611,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
resultRelationInfo->ri_IndexRelationDescs = NULL;
resultRelationInfo->ri_IndexRelationInfo = NULL;
/******************
/*
* open indices on result relation and save descriptors
* in the result relation information..
******************
*/
if (operation != CMD_DELETE)
ExecOpenIndices(resultRelationOid, resultRelationInfo);
@ -635,9 +622,8 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
}
else
{
/******************
/*
* if no result relation, then set state appropriately
******************
*/
estate->es_result_relation_info = NULL;
}
@ -670,9 +656,8 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
}
}
/******************
/*
* initialize the executor "tuple" table.
******************
*/
{
int nSlots = ExecCountSlotsNode(plan);
@ -681,33 +666,30 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
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.
******************
* SELECT added by daveh@insightdist.com 5/20/98 to allow
* ORDER/GROUP BY have an identifier missing from the target.
*/
@ -744,9 +726,8 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
estate->es_junkFilter = NULL;
}
/******************
/*
* initialize the "into" relation
******************
*/
intoRelationDesc = (Relation) NULL;
@ -764,9 +745,8 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
*/
if (parseTree->into != NULL)
{
/******************
/*
* create the "into" relation
******************
*/
intoName = parseTree->into;
@ -780,11 +760,10 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
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);
@ -817,22 +796,19 @@ EndPlan(Plan *plan, EState *estate)
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;
@ -841,9 +817,8 @@ EndPlan(Plan *plan, EState *estate)
estate->es_tupleTable = NULL;
}
/******************
/*
* close the result relations if necessary
******************
*/
if (resultRelationInfo != NULL)
{
@ -852,16 +827,14 @@ EndPlan(Plan *plan, EState *estate)
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);
@ -900,31 +873,27 @@ ExecutePlan(EState *estate,
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 (;;)
{
/******************
/*
* Execute the plan and obtain a tuple
******************
*/
/* at the top level, the parent of a plan (2nd arg) is itself */
lnext:;
@ -937,11 +906,10 @@ lnext:;
else
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))
{
@ -949,13 +917,12 @@ lnext:;
break;
}
/******************
/*
* For now we completely execute the plan and skip
* result tuples if requested by LIMIT offset.
* Finally we should try to do it in deeper levels
* if possible (during index scan)
* - Jan
******************
*/
if (offsetTuples > 0)
{
@ -963,7 +930,7 @@ lnext:;
continue;
}
/******************
/*
* if we have a junk filter, then project a new
* tuple with the junk removed.
*
@ -971,7 +938,6 @@ lnext:;
* original tuple.
*
* Also, extract all the junk information we need.
******************
*/
if ((junkfilter = estate->es_junkFilter) != (JunkFilter *) NULL)
{
@ -979,9 +945,8 @@ lnext:;
HeapTuple newTuple;
bool isNull;
/******************
/*
* extract the 'ctid' junk attribute.
******************
*/
if (operation == CMD_UPDATE || operation == CMD_DELETE)
{
@ -1063,10 +1028,9 @@ lmark:;
}
}
/******************
/*
* Finally create a new "clean" tuple with all junk attributes
* removed
******************
*/
newTuple = ExecRemoveJunk(junkfilter, slot);
@ -1077,12 +1041,11 @@ lmark:;
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)
@ -1114,21 +1077,19 @@ lmark:;
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;
}
@ -1151,16 +1112,14 @@ ExecRetrieve(TupleTableSlot *slot,
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)
{
@ -1168,9 +1127,8 @@ ExecRetrieve(TupleTableSlot *slot,
IncrAppended();
}
/******************
/*
* send the tuple to the front end (or the screen)
******************
*/
(*destfunc->receiveTuple) (tuple, attrtype, destfunc);
IncrRetrieved();
@ -1197,23 +1155,20 @@ ExecAppend(TupleTableSlot *slot,
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 */
@ -1235,9 +1190,8 @@ ExecAppend(TupleTableSlot *slot,
}
}
/******************
/*
* Check the constraints of a tuple
******************
*/
if (resultRelationDesc->rd_att->constr)
@ -1245,21 +1199,19 @@ ExecAppend(TupleTableSlot *slot,
ExecConstraints("ExecAppend", resultRelationDesc, tuple, estate);
}
/******************
/*
* 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)
@ -1290,9 +1242,8 @@ ExecDelete(TupleTableSlot *slot,
ItemPointerData ctid;
int result;
/******************
/*
* get the result relation information
******************
*/
resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc;
@ -1346,7 +1297,7 @@ ldelete:;
IncrDeleted();
(estate->es_processed)++;
/******************
/*
* Note: Normally one would think that we have to
* delete index tuples associated with the
* heap tuple now..
@ -1355,7 +1306,6 @@ ldelete:;
* 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 */
@ -1388,9 +1338,8 @@ ExecReplace(TupleTableSlot *slot,
int result;
int numIndices;
/******************
/*
* abort the operation if not running transactions
******************
*/
if (IsBootstrapProcessingMode())
{
@ -1398,25 +1347,22 @@ ExecReplace(TupleTableSlot *slot,
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 */
@ -1438,9 +1384,8 @@ ExecReplace(TupleTableSlot *slot,
}
}
/******************
/*
* Check the constraints of a tuple
******************
*/
if (resultRelationDesc->rd_att->constr)
@ -1487,7 +1432,7 @@ lreplace:;
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
@ -1495,10 +1440,9 @@ lreplace:;
* 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
@ -1506,7 +1450,6 @@ lreplace:;
* 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;

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.44 1999/02/21 03:48:39 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.45 1999/02/22 19:40:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -53,9 +53,8 @@
#include "utils/memutils.h"
/******************
/*
* externs and constants
******************
*/
/*
@ -84,14 +83,13 @@ static Datum ExecMakeFunctionResult(Node *node, List *arguments,
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,
@ -233,9 +231,8 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
bool byval;
int16 len;
/******************
/*
* get the slot we want
******************
*/
switch (variable->varno)
{
@ -253,9 +250,8 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
break;
}
/******************
/*
* extract tuple information from the slot
******************
*/
heapTuple = slot->val;
tuple_type = slot->ttc_tupleDescriptor;
@ -302,14 +298,13 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
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
@ -317,15 +312,13 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
* 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 */
@ -490,7 +483,7 @@ ExecEvalParam(Param *expression, ExprContext *econtext, bool *isNull)
* ----------------------------------------------------------------
*/
/******************
/*
* GetAttributeByName
* GetAttributeByNum
*
@ -498,7 +491,6 @@ ExecEvalParam(Param *expression, ExprContext *econtext, bool *isNull)
* 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 *
@ -617,12 +609,11 @@ ExecEvalFuncArgs(FunctionCachePtr fcache,
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),
@ -645,9 +636,8 @@ ExecEvalFuncArgs(FunctionCachePtr fcache,
}
}
/******************
/*
* ExecMakeFunctionResult
******************
*/
static Datum
ExecMakeFunctionResult(Node *node,
@ -680,12 +670,11 @@ 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)
{
@ -753,10 +742,9 @@ ExecMakeFunctionResult(Node *node,
}
}
/******************
/*
* now return the value gotten by calling the function manager,
* passing the function the evaluated parameter values.
******************
*/
if (fcache->language == SQLlanguageId)
{
@ -854,14 +842,13 @@ ExecEvalOper(Expr *opClause, ExprContext *econtext, bool *isNull)
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;
@ -877,10 +864,9 @@ ExecEvalOper(Expr *opClause, ExprContext *econtext, bool *isNull)
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);
}
@ -900,7 +886,7 @@ ExecEvalFunc(Expr *funcClause,
List *argList;
FunctionCachePtr fcache;
/******************
/*
* an funcclause is a list (func args). (I think)
*
* we extract the oid of the function associated with
@ -909,7 +895,6 @@ ExecEvalFunc(Expr *funcClause,
* calling the function on the evaluated arguments.
*
* this is nearly identical to the ExecEvalOper code.
******************
*/
func = (Func *) funcClause->oper;
argList = funcClause->args;
@ -953,25 +938,22 @@ ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull)
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;
@ -995,7 +977,7 @@ ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
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
@ -1005,33 +987,30 @@ ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
* 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 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).
@ -1044,13 +1023,12 @@ ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
* 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;
@ -1078,41 +1056,37 @@ ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull)
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;
@ -1142,20 +1116,18 @@ ExecEvalCase(CaseExpr *caseExpr, ExprContext *econtext, bool *isNull)
clauses = caseExpr->args;
/******************
/*
* we evaluate each of the WHEN clauses in turn,
* as soon as one is true we return the corresponding
* result. If none are true then we return the value
* of the default clause, or NULL.
******************
*/
foreach(clause, clauses)
{
/******************
/*
* We don't iterate over sets in the quals, so pass in an isDone
* flag, but ignore it.
******************
*/
wclause = lfirst(clause);
@ -1164,10 +1136,9 @@ ExecEvalCase(CaseExpr *caseExpr, ExprContext *econtext, bool *isNull)
isNull,
&isDone);
/******************
/*
* if we have a true test, then we return the result,
* since the case statement is satisfied.
******************
*/
if (DatumGetInt32(const_value) != 0)
{
@ -1232,10 +1203,9 @@ ExecEvalExpr(Node *expression,
if (isDone)
*isDone = true;
/******************
/*
* here we dispatch the work to the appropriate type
* of function given the type of our expression.
******************
*/
if (expression == NULL)
{
@ -1354,19 +1324,17 @@ ExecQualClause(Node *clause, ExprContext *econtext)
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;
@ -1387,9 +1355,8 @@ ExecQual(List *qual, ExprContext *econtext)
List *clause;
bool result;
/******************
/*
* debugging stuff
******************
*/
EV_printf("ExecQual: qual is ");
EV_nodeDisplay(qual);
@ -1397,21 +1364,19 @@ ExecQual(List *qual, ExprContext *econtext)
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;
@ -1422,11 +1387,10 @@ ExecQual(List *qual, ExprContext *econtext)
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;
@ -1482,23 +1446,21 @@ ExecTargetList(List *targetlist,
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
@ -1512,18 +1474,16 @@ ExecTargetList(List *targetlist,
* 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)
{
@ -1536,23 +1496,21 @@ ExecTargetList(List *targetlist,
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:
*
* ((<resdom | fjoin> expr) (<resdom | fjoin> 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);
@ -1626,16 +1584,14 @@ ExecTargetList(List *targetlist,
}
}
/******************
/*
* 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);
@ -1667,16 +1623,14 @@ ExecProject(ProjectionInfo *projInfo, bool *isDone)
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;
@ -1692,9 +1646,8 @@ ExecProject(ProjectionInfo *projInfo, bool *isDone)
return (TupleTableSlot *) NULL;
}
/******************
/*
* form a new (result) tuple
******************
*/
newTuple = ExecTargetList(targetlist,
len,
@ -1703,13 +1656,12 @@ ExecProject(ProjectionInfo *projInfo, bool *isDone)
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 */

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.21 1999/02/13 23:15:24 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.22 1999/02/22 19:40:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -26,12 +26,12 @@
* Skip Inner SKIPINNER
* mark inner position JOINMARK
* do forever { -
* while (outer ** inner) { JOINTEST
* while (outer == inner) { JOINTEST
* join tuples JOINTUPLES
* advance inner position NEXTINNER
* } -
* advance outer position NEXTOUTER
* if (outer ** mark) { TESTOUTER
* if (outer == mark) { TESTOUTER
* restore inner position to mark TESTOUTER
* continue -
* } else { -
@ -42,7 +42,7 @@
* } -
*
* Skip Outer { SKIPOUTER
* if (inner ** outer) Join Tuples JOINTUPLES
* if (inner == outer) Join Tuples JOINTUPLES
* while (outer < inner) SKIPOUTER
* advance outer SKIPOUTER
* if (outer > inner) SKIPOUTER
@ -50,7 +50,7 @@
* } -
*
* Skip Inner { SKIPINNER
* if (inner ** outer) Join Tuples JOINTUPLES
* if (inner == outer) Join Tuples JOINTUPLES
* while (outer > inner) SKIPINNER
* advance inner SKIPINNER
* if (outer < inner) SKIPINNER
@ -475,13 +475,13 @@ ExecMergeJoin(MergeJoin *node)
switch (mergestate->mj_JoinState)
{
/*
* ******************************** EXEC_MJ_INITIALIZE
/* ---------------------------------------------------
* EXEC_MJ_INITIALIZE
* means that this is the first time ExecMergeJoin() has
* been called and so we have to initialize the inner,
* outer and marked tuples as well as various stuff in the
* expression context. ********************************
*
* expression context.
* ---------------------------------------------------
*/
case EXEC_MJ_INITIALIZE:
MJ_printf("ExecMergeJoin: EXEC_MJ_INITIALIZE\n");
@ -522,12 +522,12 @@ ExecMergeJoin(MergeJoin *node)
mergestate->mj_JoinState = EXEC_MJ_SKIPINNER;
break;
/*
* ******************************** EXEC_MJ_JOINMARK means
* we have just found a new outer tuple and a possible
/* ---------------------------------------------------
* EXEC_MJ_JOINMARK
* means we have just found a new outer tuple and a possible
* matching inner tuple. This is the case after the
* INITIALIZE, SKIPOUTER or SKIPINNER states. ********************************
*
* INITIALIZE, SKIPOUTER or SKIPINNER states.
* ----------------------------------------------------
*/
case EXEC_MJ_JOINMARK:
MJ_printf("ExecMergeJoin: EXEC_MJ_JOINMARK\n");
@ -538,16 +538,16 @@ ExecMergeJoin(MergeJoin *node)
mergestate->mj_JoinState = EXEC_MJ_JOINTEST;
break;
/*
* ******************************** EXEC_MJ_JOINTEST means
* we have two tuples which might satisify the merge
/* ----------------------------------------------------
* EXEC_MJ_JOINTEST
* means we have two tuples which might satisify the merge
* clause, so we test them.
*
* If they do satisify, then we join them and move on to the
* next inner tuple (EXEC_MJ_JOINTUPLES).
*
* If they do not satisify then advance to next outer tuple. ********************************
*
* If they do not satisify then advance to next outer tuple.
* ------------------------------------------------------
*/
case EXEC_MJ_JOINTEST:
MJ_printf("ExecMergeJoin: EXEC_MJ_JOINTEST\n");
@ -561,12 +561,12 @@ ExecMergeJoin(MergeJoin *node)
mergestate->mj_JoinState = EXEC_MJ_NEXTOUTER;
break;
/*
* ******************************** EXEC_MJ_JOINTUPLES
/* ----------------------------------------------------
* EXEC_MJ_JOINTUPLES
* means we have two tuples which satisified the merge
* clause so we join them and then proceed to get the next
* inner tuple (EXEC_NEXT_INNER). ********************************
*
* inner tuple (EXEC_NEXT_INNER).
* ----------------------------------------------------
*/
case EXEC_MJ_JOINTUPLES:
MJ_printf("ExecMergeJoin: EXEC_MJ_JOINTUPLES\n");
@ -596,12 +596,12 @@ ExecMergeJoin(MergeJoin *node)
}
break;
/*
* ******************************** EXEC_MJ_NEXTINNER
/* --------------------------------------------------
* EXEC_MJ_NEXTINNER
* means advance the inner scan to the next tuple. If the
* tuple is not nil, we then proceed to test it against
* the join qualification. ********************************
*
* the join qualification.
* ----------------------------------------------------
*/
case EXEC_MJ_NEXTINNER:
MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTINNER\n");
@ -620,18 +620,20 @@ ExecMergeJoin(MergeJoin *node)
mergestate->mj_JoinState = EXEC_MJ_JOINTEST;
break;
/*
* ******************************** EXEC_MJ_NEXTOUTER
/* --------------------------------------------------
* EXEC_MJ_NEXTOUTER
* means
*
* outer inner outer tuple - 5 5 - marked tuple 5 5
* 6 6 - inner tuple 7 7
* outer inner
* outer tuple - 5 5 - marked tuple
* 5 5
* 6 6 - inner tuple
* 7 7
*
* we know we just bumped into the first inner tuple >
* current outer tuple so get a new outer tuple and then
* proceed to test it against the marked tuple
* (EXEC_MJ_TESTOUTER) ********************************
*
* (EXEC_MJ_TESTOUTER)
* -------------------------------------------------
*/
case EXEC_MJ_NEXTOUTER:
MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTOUTER\n");
@ -654,35 +656,40 @@ ExecMergeJoin(MergeJoin *node)
mergestate->mj_JoinState = EXEC_MJ_TESTOUTER;
break;
/*
* ******************************** EXEC_MJ_TESTOUTER If
* the new outer tuple and the marked tuple satisify the
/* ---------------------------------------------------
* EXEC_MJ_TESTOUTER
* If the new outer tuple and the marked tuple satisify the
* merge clause then we know we have duplicates in the
* outer scan so we have to restore the inner scan to the
* marked tuple and proceed to join the new outer tuples
* with the inner tuples (EXEC_MJ_JOINTEST)
*
* This is the case when
*
* outer inner 4 5 - marked tuple outer tuple - 5 5
* new outer tuple - 5 5 6 8 - inner tuple 7 12
* outer inner
* 4 5 - marked tuple
* outer tuple - 5 5
* new outer tuple - 5 5
* 6 8 - inner tuple
* 7 12
*
* new outer tuple = marked tuple
*
* If the outer tuple fails the test, then we know we have to
* proceed to skip outer tuples until outer >= inner
* If the outer tuple fails the test, then we know we have
* to proceed to skip outer tuples until outer >= inner
* (EXEC_MJ_SKIPOUTER).
*
* This is the case when
*
* outer inner 5 5 - marked tuple outer tuple - 5 5
* new outer tuple - 6 8 - inner tuple 7 12
* outer inner
* 5 5 - marked tuple
* outer tuple - 5 5
* new outer tuple - 6 8 - inner tuple
* 7 12
*
*
* new outer tuple > marked tuple
*
***************************
*
*
* -----------------------------------------------------------
*/
case EXEC_MJ_TESTOUTER:
MJ_printf("ExecMergeJoin: EXEC_MJ_TESTOUTER\n");
@ -746,27 +753,23 @@ ExecMergeJoin(MergeJoin *node)
}
break;
/*
* ******************************** EXEC_MJ_SKIPOUTER
/* --------------------------------------------------
* EXEC_MJ_SKIPOUTER
* means skip over tuples in the outer plan until we find
* an outer tuple > current inner tuple.
*
* For example:
*
* outer inner 5 5 5 5 outer tuple - 6 8 -
* inner tuple 7 12 8 14
* outer inner
* 5 5
* 5 5
* outer tuple - 6 8 - inner tuple
* 7 12
* 8 14
*
* we have to advance the outer scan until we find the outer
* We have to advance the outer scan until we find the outer
* 8.
*
**************************
*
*
*
*
*
*
*
* ------------------------------------------------
*/
case EXEC_MJ_SKIPOUTER:
MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPOUTER\n");
@ -848,27 +851,22 @@ ExecMergeJoin(MergeJoin *node)
mergestate->mj_JoinState = EXEC_MJ_JOINMARK;
break;
/*
* ******************************** EXEC_MJ_SKIPINNER
/* ------------------------------------------------
* EXEC_MJ_SKIPINNER
* means skip over tuples in the inner plan until we find
* an inner tuple > current outer tuple.
*
* For example:
* outer inner
* 5 5
* 5 5
* outer tuple - 12 8 - inner tuple
* 14 10
* 17 12
*
* outer inner 5 5 5 5 outer tuple - 12 8 - inner
* tuple 14 10 17 12
*
* we have to advance the inner scan until we find the inner
* We have to advance the inner scan until we find the inner
* 12.
*
**************************
*
*
*
*
*
*
*
* ---------------------------------------------------
*/
case EXEC_MJ_SKIPINNER:
MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPINNER\n");
@ -971,10 +969,8 @@ ExecMergeJoin(MergeJoin *node)
break;
/*
* ******************************** if we get here it
* means our code is fucked up and so we just end the join
* prematurely. ********************************
*
* If we get here it means our code is messed up and so we
* just end the join prematurely.
*/
default:
elog(NOTICE, "ExecMergeJoin: invalid join state. aborting");