diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index f470abb6b645d9d822af379a526f63ebad502399..f9cd8d035a19ed3f8aedbb87654894a0251af75a 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.55 1998/09/01 04:28:16 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.56 1998/09/25 13:38:30 thomas Exp $ * *------------------------------------------------------------------------- */ @@ -168,16 +168,16 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count) CommandDest dest; void (*destination) (); - /* ---------------- + /****************** * sanity checks - * ---------------- + ****************** */ Assert(queryDesc != NULL); - /* ---------------- + /****************** * extract information from the query descriptor * and the query feature. - * ---------------- + ****************** */ operation = queryDesc->operation; parseTree = queryDesc->parsetree; @@ -209,9 +209,9 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count) destination); break; - /* ---------------- + /****************** * retrieve next n "backward" tuples - * ---------------- + ****************** */ case EXEC_BACK: result = ExecutePlan(estate, @@ -223,10 +223,10 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count) 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, @@ -389,40 +389,40 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *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; @@ -455,10 +455,10 @@ 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.. - * ---------------- + ****************** */ ExecOpenIndices(resultRelationOid, resultRelationInfo); @@ -466,9 +466,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate) } else { - /* ---------------- + /****************** * if no result relation, then set state appropriately - * ---------------- + ****************** */ estate->es_result_relation_info = NULL; } @@ -477,9 +477,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate) ExecCheckPerms(operation, resultRelation, rangeTable, parseTree); #endif - /* ---------------- + /****************** * initialize the executor "tuple" table. - * ---------------- + ****************** */ { int nSlots = ExecCountSlotsNode(plan); @@ -488,33 +488,33 @@ 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. */ @@ -551,9 +551,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate) estate->es_junkFilter = NULL; } - /* ---------------- + /****************** * initialize the "into" relation - * ---------------- + ****************** */ intoRelationDesc = (Relation) NULL; @@ -571,9 +571,9 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate) */ if (parseTree->into != NULL) { - /* ---------------- + /****************** * create the "into" relation - * ---------------- + ****************** */ intoName = parseTree->into; @@ -587,11 +587,11 @@ 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); @@ -619,22 +619,22 @@ 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; @@ -643,9 +643,9 @@ EndPlan(Plan *plan, EState *estate) estate->es_tupleTable = NULL; } - /* ---------------- + /****************** * close the result relations if necessary - * ---------------- + ****************** */ if (resultRelationInfo != NULL) { @@ -654,16 +654,16 @@ 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); @@ -702,42 +702,42 @@ 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 (;;) { 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)) { @@ -746,15 +746,15 @@ ExecutePlan(EState *estate, } } - /* ---------------- + /****************** * 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) { @@ -764,9 +764,9 @@ ExecutePlan(EState *estate, HeapTuple newTuple; bool isNull; - /* --------------- + /****************** * extract the 'ctid' junk attribute. - * --------------- + ****************** */ if (operation == CMD_UPDATE || operation == CMD_DELETE) { @@ -786,10 +786,10 @@ ExecutePlan(EState *estate, tupleid = &tuple_ctid; } - /* --------------- + /****************** * Finally create a new "clean" tuple with all junk attributes * removed - * --------------- + ****************** */ newTuple = ExecRemoveJunk(junkfilter, slot); @@ -800,12 +800,12 @@ ExecutePlan(EState *estate, 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) @@ -855,21 +855,21 @@ ExecutePlan(EState *estate, 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; } @@ -892,16 +892,16 @@ 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) { @@ -909,9 +909,9 @@ ExecRetrieve(TupleTableSlot *slot, IncrAppended(); } - /* ---------------- + /****************** * send the tuple to the front end (or the screen) - * ---------------- + ****************** */ (*printfunc) (tuple, attrtype); IncrRetrieved(); @@ -938,23 +938,23 @@ 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 */ @@ -976,9 +976,9 @@ ExecAppend(TupleTableSlot *slot, } } - /* ---------------- + /****************** * Check the constraints of a tuple - * ---------------- + ****************** */ if (resultRelationDesc->rd_att->constr) @@ -995,21 +995,21 @@ ExecAppend(TupleTableSlot *slot, } } - /* ---------------- + /****************** * 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) @@ -1038,9 +1038,9 @@ ExecDelete(TupleTableSlot *slot, RelationInfo *resultRelationInfo; Relation resultRelationDesc; - /* ---------------- + /****************** * get the result relation information - * ---------------- + ****************** */ resultRelationInfo = estate->es_result_relation_info; resultRelationDesc = resultRelationInfo->ri_RelationDesc; @@ -1057,9 +1057,9 @@ ExecDelete(TupleTableSlot *slot, return; } - /* ---------------- + /****************** * delete the tuple - * ---------------- + ****************** */ if (heap_delete(resultRelationDesc, /* relation desc */ tupleid)) /* item pointer to tuple */ @@ -1068,7 +1068,7 @@ ExecDelete(TupleTableSlot *slot, IncrDeleted(); (estate->es_processed)++; - /* ---------------- + /****************** * Note: Normally one would think that we have to * delete index tuples associated with the * heap tuple now.. @@ -1077,7 +1077,7 @@ ExecDelete(TupleTableSlot *slot, * 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 */ @@ -1109,9 +1109,9 @@ ExecReplace(TupleTableSlot *slot, Relation resultRelationDesc; int numIndices; - /* ---------------- + /****************** * abort the operation if not running transactions - * ---------------- + ****************** */ if (IsBootstrapProcessingMode()) { @@ -1119,25 +1119,25 @@ 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 */ @@ -1159,9 +1159,9 @@ ExecReplace(TupleTableSlot *slot, } } - /* ---------------- + /****************** * Check the constraints of a tuple - * ---------------- + ****************** */ if (resultRelationDesc->rd_att->constr) @@ -1178,13 +1178,13 @@ ExecReplace(TupleTableSlot *slot, } } - /* ---------------- + /****************** * 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 */ @@ -1196,7 +1196,7 @@ ExecReplace(TupleTableSlot *slot, 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 @@ -1204,10 +1204,10 @@ ExecReplace(TupleTableSlot *slot, * 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 @@ -1215,7 +1215,7 @@ ExecReplace(TupleTableSlot *slot, * 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; diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c index f3d12b1319b25e8fa67a9eda0e9db996a1c90a32..680bf9939ed85d90a2c8b6d8f01fa5cb88308aed 100644 --- a/src/backend/executor/execQual.c +++ b/src/backend/executor/execQual.c @@ -7,7 +7,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.36 1998/09/01 04:28:18 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.37 1998/09/25 13:38:31 thomas Exp $ * *------------------------------------------------------------------------- */ @@ -53,9 +53,9 @@ #include "utils/memutils.h" -/* ---------------- +/****************** * externs and constants - * ---------------- + ****************** */ /* @@ -84,15 +84,14 @@ 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, @@ -234,9 +233,9 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull) bool byval; int16 len; - /* ---------------- + /****************** * get the slot we want - * ---------------- + ****************** */ switch (variable->varno) { @@ -254,9 +253,9 @@ ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull) break; } - /* ---------------- + /****************** * extract tuple information from the slot - * ---------------- + ****************** */ heapTuple = slot->val; tuple_type = slot->ttc_tupleDescriptor; @@ -303,14 +302,14 @@ 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 @@ -318,15 +317,15 @@ 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 */ @@ -491,7 +490,7 @@ ExecEvalParam(Param *expression, ExprContext *econtext, bool *isNull) * ---------------------------------------------------------------- */ -/* ---------------- +/****************** * GetAttributeByName * GetAttributeByNum * @@ -499,7 +498,7 @@ 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 * @@ -621,12 +620,12 @@ 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), @@ -649,9 +648,9 @@ ExecEvalFuncArgs(FunctionCachePtr fcache, } } -/* ---------------- +/****************** * ExecMakeFunctionResult - * ---------------- + ****************** */ static Datum ExecMakeFunctionResult(Node *node, @@ -684,12 +683,12 @@ 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) { @@ -757,10 +756,10 @@ ExecMakeFunctionResult(Node *node, } } - /* ---------------- + /****************** * now return the value gotten by calling the function manager, * passing the function the evaluated parameter values. - * ---------------- + ****************** */ if (fcache->language == SQLlanguageId) { @@ -858,14 +857,14 @@ 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; @@ -881,10 +880,10 @@ 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); @@ -905,7 +904,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 @@ -914,7 +913,7 @@ 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; @@ -959,25 +958,25 @@ 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; @@ -1001,7 +1000,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 @@ -1011,51 +1010,52 @@ 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 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; @@ -1083,41 +1083,41 @@ 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; @@ -1164,10 +1164,10 @@ 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) { @@ -1281,19 +1281,19 @@ 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; @@ -1314,9 +1314,9 @@ ExecQual(List *qual, ExprContext *econtext) List *clause; bool result; - /* ---------------- + /****************** * debugging stuff - * ---------------- + ****************** */ EV_printf("ExecQual: qual is "); EV_nodeDisplay(qual); @@ -1324,21 +1324,21 @@ 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; @@ -1349,11 +1349,11 @@ 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; @@ -1409,23 +1409,23 @@ 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 @@ -1439,18 +1439,18 @@ 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) { @@ -1463,23 +1463,23 @@ 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: * * (( 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); @@ -1553,16 +1553,16 @@ 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); @@ -1595,16 +1595,16 @@ 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; @@ -1620,9 +1620,9 @@ ExecProject(ProjectionInfo *projInfo, bool *isDone) return (TupleTableSlot *) NULL; } - /* ---------------- + /****************** * form a new (result) tuple - * ---------------- + ****************** */ newTuple = ExecTargetList(targetlist, len, @@ -1631,13 +1631,13 @@ 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 */ diff --git a/src/backend/executor/nodeSeqscan.c b/src/backend/executor/nodeSeqscan.c index c5bceea06b21b2c4a13feac5510fbb9f1fe5ef08..a9da3e769d274dd711c939f9eccb557b5034245d 100644 --- a/src/backend/executor/nodeSeqscan.c +++ b/src/backend/executor/nodeSeqscan.c @@ -7,7 +7,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.14 1998/09/01 04:28:37 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.15 1998/09/25 13:38:32 thomas Exp $ * *------------------------------------------------------------------------- */ @@ -29,6 +29,7 @@ #include "executor/nodeSeqscan.h" #include "access/heapam.h" #include "parser/parsetree.h" +#include "nodes/print.h" static Oid InitScanRelation(SeqScan *node, EState *estate, CommonScanState *scanstate, Plan *outerPlan);