*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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;
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)
{
elog(ERROR, "limit offset cannot be negative");
}
- /******************
+ /*
* if given get the count of the LIMIT clause
- ******************
*/
if (limcount != NULL)
{
destfunc);
break;
- /******************
+ /*
* retrieve next n "backward" tuples
- ******************
*/
case EXEC_BACK:
result = ExecutePlan(estate,
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,
List *targetList;
int len;
- /******************
+ /*
* get information from query descriptor
- ******************
*/
rangeTable = parseTree->rtable;
resultRelation = parseTree->resultRelation;
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;
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);
}
else
{
- /******************
+ /*
* if no result relation, then set state appropriately
- ******************
*/
estate->es_result_relation_info = NULL;
}
}
}
- /******************
+ /*
* 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 (;;)
{
- /******************
+ /*
* Execute the plan and obtain a tuple
- ******************
*/
/* at the top level, the parent of a plan (2nd arg) is itself */
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))
{
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)
{
continue;
}
- /******************
+ /*
* if we have a junk filter, then project a new
* tuple with the junk removed.
*
* original tuple.
*
* 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)
{
}
}
- /******************
+ /*
* 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)
- ******************
*/
(*destfunc->receiveTuple) (tuple, attrtype, destfunc);
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)
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)
ItemPointerData ctid;
int result;
- /******************
+ /*
* get the result relation information
- ******************
*/
resultRelationInfo = estate->es_result_relation_info;
resultRelationDesc = resultRelationInfo->ri_RelationDesc;
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 */
int result;
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)
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.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 $
*
*-------------------------------------------------------------------------
*/
#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 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).
* 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;
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);
isNull,
&isDone);
- /******************
+ /*
* if we have a true test, then we return the result,
* since the case statement is satisfied.
- ******************
*/
if (DatumGetInt32(const_value) != 0)
{
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/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 $
*
*-------------------------------------------------------------------------
*/
* 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 { -
* } -
*
* 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
* } -
*
* 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
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");
econtext->ecxt_outertuple = outerTupleSlot;
mergestate->mj_MarkedTupleSlot->ttc_tupleDescriptor =
- innerTupleSlot->ttc_tupleDescriptor;
+ innerTupleSlot->ttc_tupleDescriptor;
/* ----------------
* initialize merge join state to skip inner tuples.
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");
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");
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");
}
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");
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");
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
*
- * 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
+ * (EXEC_MJ_SKIPOUTER).
*
- * 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
*
- * 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
- *
- ***************************
*
+ * new outer tuple > marked tuple
*
+ * -----------------------------------------------------------
*/
case EXEC_MJ_TESTOUTER:
MJ_printf("ExecMergeJoin: EXEC_MJ_TESTOUTER\n");
}
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");
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");
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");
projects / postgresql.git / commitdiff