diff options
Diffstat (limited to 'src/backend/executor/execMain.c')
| -rw-r--r-- | src/backend/executor/execMain.c | 173 |
1 files changed, 58 insertions, 115 deletions
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index 379a7be04be..5180486b8b6 100644 --- a/src/backend/executor/execMain.c +++ b/src/backend/executor/execMain.c @@ -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; |