granicus.if.org Git - postgresql/blob - src/backend/executor/execQual.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * execQual.c
   4  *        Routines to evaluate qualification and targetlist expressions
   5  *
   6  * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL: pgsql/src/backend/executor/execQual.c,v 1.192 2006/07/14 14:52:19 momjian Exp $
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 /*
  16  *       INTERFACE ROUTINES
  17  *              ExecEvalExpr    - (now a macro) evaluate an expression, return a datum
  18  *              ExecEvalExprSwitchContext - same, but switch into eval memory context
  19  *              ExecQual                - return true/false if qualification is satisfied
  20  *              ExecProject             - form a new tuple by projecting the given tuple
  21  *
  22  *       NOTES
  23  *              The more heavily used ExecEvalExpr routines, such as ExecEvalVar(),
  24  *              are hotspots. Making these faster will speed up the entire system.
  25  *
  26  *              ExecProject() is used to make tuple projections.  Rather then
  27  *              trying to speed it up, the execution plan should be pre-processed
  28  *              to facilitate attribute sharing between nodes wherever possible,
  29  *              instead of doing needless copying.      -cim 5/31/91
  30  *
  31  *              During expression evaluation, we check_stack_depth only in
  32  *              ExecMakeFunctionResult rather than at every single node.  This
  33  *              is a compromise that trades off precision of the stack limit setting
  34  *              to gain speed.
  35  */
  36
  37 #include "postgres.h"
  38
  39 #include "access/heapam.h"
  40 #include "access/nbtree.h"
  41 #include "catalog/pg_type.h"
  42 #include "commands/typecmds.h"
  43 #include "executor/execdebug.h"
  44 #include "executor/nodeSubplan.h"
  45 #include "funcapi.h"
  46 #include "miscadmin.h"
  47 #include "nodes/makefuncs.h"
  48 #include "optimizer/planmain.h"
  49 #include "parser/parse_expr.h"
  50 #include "utils/acl.h"
  51 #include "utils/builtins.h"
  52 #include "utils/lsyscache.h"
  53 #include "utils/memutils.h"
  54 #include "utils/typcache.h"
  55
  56
  57 /* static function decls */
  58 static Datum ExecEvalArrayRef(ArrayRefExprState *astate,
  59                                  ExprContext *econtext,
  60                                  bool *isNull, ExprDoneCond *isDone);
  61 static Datum ExecEvalAggref(AggrefExprState *aggref,
  62                            ExprContext *econtext,
  63                            bool *isNull, ExprDoneCond *isDone);
  64 static Datum ExecEvalVar(ExprState *exprstate, ExprContext *econtext,
  65                         bool *isNull, ExprDoneCond *isDone);
  66 static Datum ExecEvalWholeRowVar(ExprState *exprstate, ExprContext *econtext,
  67                                         bool *isNull, ExprDoneCond *isDone);
  68 static Datum ExecEvalConst(ExprState *exprstate, ExprContext *econtext,
  69                           bool *isNull, ExprDoneCond *isDone);
  70 static Datum ExecEvalParam(ExprState *exprstate, ExprContext *econtext,
  71                           bool *isNull, ExprDoneCond *isDone);
  72 static void ShutdownFuncExpr(Datum arg);
  73 static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod,
  74                                    TupleDesc *cache_field, ExprContext *econtext);
  75 static void ShutdownTupleDescRef(Datum arg);
  76 static ExprDoneCond ExecEvalFuncArgs(FunctionCallInfo fcinfo,
  77                                  List *argList, ExprContext *econtext);
  78 static Datum ExecMakeFunctionResultNoSets(FuncExprState *fcache,
  79                                                          ExprContext *econtext,
  80                                                          bool *isNull, ExprDoneCond *isDone);
  81 static Datum ExecEvalFunc(FuncExprState *fcache, ExprContext *econtext,
  82                          bool *isNull, ExprDoneCond *isDone);
  83 static Datum ExecEvalOper(FuncExprState *fcache, ExprContext *econtext,
  84                          bool *isNull, ExprDoneCond *isDone);
  85 static Datum ExecEvalDistinct(FuncExprState *fcache, ExprContext *econtext,
  86                                  bool *isNull, ExprDoneCond *isDone);
  87 static Datum ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
  88                                           ExprContext *econtext,
  89                                           bool *isNull, ExprDoneCond *isDone);
  90 static Datum ExecEvalNot(BoolExprState *notclause, ExprContext *econtext,
  91                         bool *isNull, ExprDoneCond *isDone);
  92 static Datum ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext,
  93                    bool *isNull, ExprDoneCond *isDone);
  94 static Datum ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext,
  95                         bool *isNull, ExprDoneCond *isDone);
  96 static Datum ExecEvalConvertRowtype(ConvertRowtypeExprState *cstate,
  97                                            ExprContext *econtext,
  98                                            bool *isNull, ExprDoneCond *isDone);
  99 static Datum ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
 100                          bool *isNull, ExprDoneCond *isDone);
 101 static Datum ExecEvalCaseTestExpr(ExprState *exprstate,
 102                                          ExprContext *econtext,
 103                                          bool *isNull, ExprDoneCond *isDone);
 104 static Datum ExecEvalArray(ArrayExprState *astate,
 105                           ExprContext *econtext,
 106                           bool *isNull, ExprDoneCond *isDone);
 107 static Datum ExecEvalRow(RowExprState *rstate,
 108                         ExprContext *econtext,
 109                         bool *isNull, ExprDoneCond *isDone);
 110 static Datum ExecEvalRowCompare(RowCompareExprState *rstate,
 111                         ExprContext *econtext,
 112                         bool *isNull, ExprDoneCond *isDone);
 113 static Datum ExecEvalCoalesce(CoalesceExprState *coalesceExpr,
 114                                  ExprContext *econtext,
 115                                  bool *isNull, ExprDoneCond *isDone);
 116 static Datum ExecEvalMinMax(MinMaxExprState *minmaxExpr,
 117                            ExprContext *econtext,
 118                            bool *isNull, ExprDoneCond *isDone);
 119 static Datum ExecEvalNullIf(FuncExprState *nullIfExpr,
 120                            ExprContext *econtext,
 121                            bool *isNull, ExprDoneCond *isDone);
 122 static Datum ExecEvalNullTest(GenericExprState *nstate,
 123                                  ExprContext *econtext,
 124                                  bool *isNull, ExprDoneCond *isDone);
 125 static Datum ExecEvalBooleanTest(GenericExprState *bstate,
 126                                         ExprContext *econtext,
 127                                         bool *isNull, ExprDoneCond *isDone);
 128 static Datum ExecEvalCoerceToDomain(CoerceToDomainState *cstate,
 129                                            ExprContext *econtext,
 130                                            bool *isNull, ExprDoneCond *isDone);
 131 static Datum ExecEvalCoerceToDomainValue(ExprState *exprstate,
 132                                                         ExprContext *econtext,
 133                                                         bool *isNull, ExprDoneCond *isDone);
 134 static Datum ExecEvalFieldSelect(FieldSelectState *fstate,
 135                                         ExprContext *econtext,
 136                                         bool *isNull, ExprDoneCond *isDone);
 137 static Datum ExecEvalFieldStore(FieldStoreState *fstate,
 138                                    ExprContext *econtext,
 139                                    bool *isNull, ExprDoneCond *isDone);
 140 static Datum ExecEvalRelabelType(GenericExprState *exprstate,
 141                                         ExprContext *econtext,
 142                                         bool *isNull, ExprDoneCond *isDone);
 143
 144
 145 /* ----------------------------------------------------------------
 146  *              ExecEvalExpr routines
 147  *
 148  *              Recursively evaluate a targetlist or qualification expression.
 149  *
 150  * Each of the following routines having the signature
 151  *              Datum ExecEvalFoo(ExprState *expression,
 152  *                                                ExprContext *econtext,
 153  *                                                bool *isNull,
 154  *                                                ExprDoneCond *isDone);
 155  * is responsible for evaluating one type or subtype of ExprState node.
 156  * They are normally called via the ExecEvalExpr macro, which makes use of
 157  * the function pointer set up when the ExprState node was built by
 158  * ExecInitExpr.  (In some cases, we change this pointer later to avoid
 159  * re-executing one-time overhead.)
 160  *
 161  * Note: for notational simplicity we declare these functions as taking the
 162  * specific type of ExprState that they work on.  This requires casting when
 163  * assigning the function pointer in ExecInitExpr.      Be careful that the
 164  * function signature is declared correctly, because the cast suppresses
 165  * automatic checking!
 166  *
 167  *
 168  * All these functions share this calling convention:
 169  *
 170  * Inputs:
 171  *              expression: the expression state tree to evaluate
 172  *              econtext: evaluation context information
 173  *
 174  * Outputs:
 175  *              return value: Datum value of result
 176  *              *isNull: set to TRUE if result is NULL (actual return value is
 177  *                               meaningless if so); set to FALSE if non-null result
 178  *              *isDone: set to indicator of set-result status
 179  *
 180  * A caller that can only accept a singleton (non-set) result should pass
 181  * NULL for isDone; if the expression computes a set result then an error
 182  * will be reported via ereport.  If the caller does pass an isDone pointer
 183  * then *isDone is set to one of these three states:
 184  *              ExprSingleResult                singleton result (not a set)
 185  *              ExprMultipleResult              return value is one element of a set
 186  *              ExprEndResult                   there are no more elements in the set
 187  * When ExprMultipleResult is returned, the caller should invoke
 188  * ExecEvalExpr() repeatedly until ExprEndResult is returned.  ExprEndResult
 189  * is returned after the last real set element.  For convenience isNull will
 190  * always be set TRUE when ExprEndResult is returned, but this should not be
 191  * taken as indicating a NULL element of the set.  Note that these return
 192  * conventions allow us to distinguish among a singleton NULL, a NULL element
 193  * of a set, and an empty set.
 194  *
 195  * The caller should already have switched into the temporary memory
 196  * context econtext->ecxt_per_tuple_memory.  The convenience entry point
 197  * ExecEvalExprSwitchContext() is provided for callers who don't prefer to
 198  * do the switch in an outer loop.      We do not do the switch in these routines
 199  * because it'd be a waste of cycles during nested expression evaluation.
 200  * ----------------------------------------------------------------
 201  */
 202
 203
 204 /*----------
 205  *        ExecEvalArrayRef
 206  *
 207  *         This function takes an ArrayRef and returns the extracted Datum
 208  *         if it's a simple reference, or the modified array value if it's
 209  *         an array assignment (i.e., array element or slice insertion).
 210  *
 211  * NOTE: if we get a NULL result from a subscript expression, we return NULL
 212  * when it's an array reference, or raise an error when it's an assignment.
 213  *
 214  * NOTE: we deliberately refrain from applying DatumGetArrayTypeP() here,
 215  * even though that might seem natural, because this code needs to support
 216  * both varlena arrays and fixed-length array types.  DatumGetArrayTypeP()
 217  * only works for the varlena kind.  The routines we call in arrayfuncs.c
 218  * have to know the difference (that's what they need refattrlength for).
 219  *----------
 220  */
 221 static Datum
 222 ExecEvalArrayRef(ArrayRefExprState *astate,
 223                                  ExprContext *econtext,
 224                                  bool *isNull,
 225                                  ExprDoneCond *isDone)
 226 {
 227         ArrayRef   *arrayRef = (ArrayRef *) astate->xprstate.expr;
 228         ArrayType  *array_source;
 229         ArrayType  *resultArray;
 230         bool            isAssignment = (arrayRef->refassgnexpr != NULL);
 231         bool            eisnull;
 232         ListCell   *l;
 233         int                     i = 0,
 234                                 j = 0;
 235         IntArray        upper,
 236                                 lower;
 237         int                *lIndex;
 238
 239         array_source = (ArrayType *)
 240                 DatumGetPointer(ExecEvalExpr(astate->refexpr,
 241                                                                          econtext,
 242                                                                          isNull,
 243                                                                          isDone));
 244
 245         /*
 246          * If refexpr yields NULL, and it's a fetch, then result is NULL. In the
 247          * assignment case, we'll cons up something below.
 248          */
 249         if (*isNull)
 250         {
 251                 if (isDone && *isDone == ExprEndResult)
 252                         return (Datum) NULL;    /* end of set result */
 253                 if (!isAssignment)
 254                         return (Datum) NULL;
 255         }
 256
 257         foreach(l, astate->refupperindexpr)
 258         {
 259                 ExprState  *eltstate = (ExprState *) lfirst(l);
 260
 261                 if (i >= MAXDIM)
 262                         ereport(ERROR,
 263                                         (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 264                                          errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
 265                                                         i, MAXDIM)));
 266
 267                 upper.indx[i++] = DatumGetInt32(ExecEvalExpr(eltstate,
 268                                                                                                          econtext,
 269                                                                                                          &eisnull,
 270                                                                                                          NULL));
 271                 /* If any index expr yields NULL, result is NULL or error */
 272                 if (eisnull)
 273                 {
 274                         if (isAssignment)
 275                                 ereport(ERROR,
 276                                                 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
 277                                   errmsg("array subscript in assignment must not be NULL")));
 278                         *isNull = true;
 279                         return (Datum) NULL;
 280                 }
 281         }
 282
 283         if (astate->reflowerindexpr != NIL)
 284         {
 285                 foreach(l, astate->reflowerindexpr)
 286                 {
 287                         ExprState  *eltstate = (ExprState *) lfirst(l);
 288
 289                         if (j >= MAXDIM)
 290                                 ereport(ERROR,
 291                                                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 292                                                  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
 293                                                                 i, MAXDIM)));
 294
 295                         lower.indx[j++] = DatumGetInt32(ExecEvalExpr(eltstate,
 296                                                                                                                  econtext,
 297                                                                                                                  &eisnull,
 298                                                                                                                  NULL));
 299                         /* If any index expr yields NULL, result is NULL or error */
 300                         if (eisnull)
 301                         {
 302                                 if (isAssignment)
 303                                         ereport(ERROR,
 304                                                         (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
 305                                                          errmsg("array subscript in assignment must not be NULL")));
 306                                 *isNull = true;
 307                                 return (Datum) NULL;
 308                         }
 309                 }
 310                 /* this can't happen unless parser messed up */
 311                 if (i != j)
 312                         elog(ERROR, "upper and lower index lists are not same length");
 313                 lIndex = lower.indx;
 314         }
 315         else
 316                 lIndex = NULL;
 317
 318         if (isAssignment)
 319         {
 320                 Datum           sourceData;
 321
 322                 /*
 323                  * Evaluate the value to be assigned into the array.
 324                  *
 325                  * XXX At some point we'll need to look into making the old value of
 326                  * the array element available via CaseTestExpr, as is done by
 327                  * ExecEvalFieldStore.  This is not needed now but will be needed to
 328                  * support arrays of composite types; in an assignment to a field of
 329                  * an array member, the parser would generate a FieldStore that
 330                  * expects to fetch its input tuple via CaseTestExpr.
 331                  */
 332                 sourceData = ExecEvalExpr(astate->refassgnexpr,
 333                                                                   econtext,
 334                                                                   &eisnull,
 335                                                                   NULL);
 336
 337                 /*
 338                  * For an assignment to a fixed-length array type, both the original
 339                  * array and the value to be assigned into it must be non-NULL, else
 340                  * we punt and return the original array.
 341                  */
 342                 if (astate->refattrlength > 0)  /* fixed-length array? */
 343                         if (eisnull || *isNull)
 344                                 return PointerGetDatum(array_source);
 345
 346                 /*
 347                  * For assignment to varlena arrays, we handle a NULL original array
 348                  * by substituting an empty (zero-dimensional) array; insertion of the
 349                  * new element will result in a singleton array value.  It does not
 350                  * matter whether the new element is NULL.
 351                  */
 352                 if (*isNull)
 353                 {
 354                         array_source = construct_empty_array(arrayRef->refelemtype);
 355                         *isNull = false;
 356                 }
 357
 358                 if (lIndex == NULL)
 359                         resultArray = array_set(array_source, i,
 360                                                                         upper.indx,
 361                                                                         sourceData,
 362                                                                         eisnull,
 363                                                                         astate->refattrlength,
 364                                                                         astate->refelemlength,
 365                                                                         astate->refelembyval,
 366                                                                         astate->refelemalign);
 367                 else
 368                         resultArray = array_set_slice(array_source, i,
 369                                                                                   upper.indx, lower.indx,
 370                                                                    (ArrayType *) DatumGetPointer(sourceData),
 371                                                                                   eisnull,
 372                                                                                   astate->refattrlength,
 373                                                                                   astate->refelemlength,
 374                                                                                   astate->refelembyval,
 375                                                                                   astate->refelemalign);
 376                 return PointerGetDatum(resultArray);
 377         }
 378
 379         if (lIndex == NULL)
 380                 return array_ref(array_source, i, upper.indx,
 381                                                  astate->refattrlength,
 382                                                  astate->refelemlength,
 383                                                  astate->refelembyval,
 384                                                  astate->refelemalign,
 385                                                  isNull);
 386         else
 387         {
 388                 resultArray = array_get_slice(array_source, i,
 389                                                                           upper.indx, lower.indx,
 390                                                                           astate->refattrlength,
 391                                                                           astate->refelemlength,
 392                                                                           astate->refelembyval,
 393                                                                           astate->refelemalign);
 394                 return PointerGetDatum(resultArray);
 395         }
 396 }
 397
 398
 399 /* ----------------------------------------------------------------
 400  *              ExecEvalAggref
 401  *
 402  *              Returns a Datum whose value is the value of the precomputed
 403  *              aggregate found in the given expression context.
 404  * ----------------------------------------------------------------
 405  */
 406 static Datum
 407 ExecEvalAggref(AggrefExprState *aggref, ExprContext *econtext,
 408                            bool *isNull, ExprDoneCond *isDone)
 409 {
 410         if (isDone)
 411                 *isDone = ExprSingleResult;
 412
 413         if (econtext->ecxt_aggvalues == NULL)           /* safety check */
 414                 elog(ERROR, "no aggregates in this expression context");
 415
 416         *isNull = econtext->ecxt_aggnulls[aggref->aggno];
 417         return econtext->ecxt_aggvalues[aggref->aggno];
 418 }
 419
 420 /* ----------------------------------------------------------------
 421  *              ExecEvalVar
 422  *
 423  *              Returns a Datum whose value is the value of a range
 424  *              variable with respect to given expression context.
 425  * ----------------------------------------------------------------
 426  */
 427 static Datum
 428 ExecEvalVar(ExprState *exprstate, ExprContext *econtext,
 429                         bool *isNull, ExprDoneCond *isDone)
 430 {
 431         Var                *variable = (Var *) exprstate->expr;
 432         TupleTableSlot *slot;
 433         AttrNumber      attnum;
 434
 435         if (isDone)
 436                 *isDone = ExprSingleResult;
 437
 438         /*
 439          * Get the slot and attribute number we want
 440          *
 441          * The asserts check that references to system attributes only appear at
 442          * the level of a relation scan; at higher levels, system attributes must
 443          * be treated as ordinary variables (since we no longer have access to the
 444          * original tuple).
 445          */
 446         attnum = variable->varattno;
 447
 448         switch (variable->varno)
 449         {
 450                 case INNER:                             /* get the tuple from the inner node */
 451                         slot = econtext->ecxt_innertuple;
 452                         Assert(attnum > 0);
 453                         break;
 454
 455                 case OUTER:                             /* get the tuple from the outer node */
 456                         slot = econtext->ecxt_outertuple;
 457                         Assert(attnum > 0);
 458                         break;
 459
 460                 default:                                /* get the tuple from the relation being
 461                                                                  * scanned */
 462                         slot = econtext->ecxt_scantuple;
 463                         break;
 464         }
 465
 466 #ifdef USE_ASSERT_CHECKING
 467
 468         /*
 469          * Some checks that are only applied for user attribute numbers (bogus
 470          * system attnums will be caught inside slot_getattr).
 471          */
 472         if (attnum > 0)
 473         {
 474                 TupleDesc       tuple_type = slot->tts_tupleDescriptor;
 475
 476                 /*
 477                  * This assert checks that the attnum is valid.
 478                  */
 479                 Assert(attnum <= tuple_type->natts);
 480
 481                 /*
 482                  * This assert checks that the datatype the plan expects to get (as
 483                  * told by our "variable" argument) is in fact the datatype of the
 484                  * attribute being fetched (as seen in the current context, identified
 485                  * by our "econtext" argument).  Otherwise crashes are likely.
 486                  *
 487                  * Note that we can't check dropped columns, since their atttypid has
 488                  * been zeroed.
 489                  */
 490                 Assert(variable->vartype == tuple_type->attrs[attnum - 1]->atttypid ||
 491                            tuple_type->attrs[attnum - 1]->attisdropped);
 492         }
 493 #endif   /* USE_ASSERT_CHECKING */
 494
 495         return slot_getattr(slot, attnum, isNull);
 496 }
 497
 498 /* ----------------------------------------------------------------
 499  *              ExecEvalWholeRowVar
 500  *
 501  *              Returns a Datum for a whole-row variable.
 502  *
 503  *              This could be folded into ExecEvalVar, but we make it a separate
 504  *              routine so as not to slow down ExecEvalVar with tests for this
 505  *              uncommon case.
 506  * ----------------------------------------------------------------
 507  */
 508 static Datum
 509 ExecEvalWholeRowVar(ExprState *exprstate, ExprContext *econtext,
 510                                         bool *isNull, ExprDoneCond *isDone)
 511 {
 512         Var                *variable = (Var *) exprstate->expr;
 513         TupleTableSlot *slot;
 514         HeapTuple       tuple;
 515         TupleDesc       tupleDesc;
 516         HeapTupleHeader dtuple;
 517
 518         if (isDone)
 519                 *isDone = ExprSingleResult;
 520         *isNull = false;
 521
 522         Assert(variable->varattno == InvalidAttrNumber);
 523
 524         /*
 525          * Whole-row Vars can only appear at the level of a relation scan, never
 526          * in a join.
 527          */
 528         Assert(variable->varno != INNER);
 529         Assert(variable->varno != OUTER);
 530         slot = econtext->ecxt_scantuple;
 531
 532         tuple = ExecFetchSlotTuple(slot);
 533         tupleDesc = slot->tts_tupleDescriptor;
 534
 535         /*
 536          * We have to make a copy of the tuple so we can safely insert the Datum
 537          * overhead fields, which are not set in on-disk tuples.
 538          */
 539         dtuple = (HeapTupleHeader) palloc(tuple->t_len);
 540         memcpy((char *) dtuple, (char *) tuple->t_data, tuple->t_len);
 541
 542         HeapTupleHeaderSetDatumLength(dtuple, tuple->t_len);
 543
 544         /*
 545          * If the Var identifies a named composite type, label the tuple with that
 546          * type; otherwise use what is in the tupleDesc.
 547          *
 548          * It's likely that the slot's tupleDesc is a record type; if so, make
 549          * sure it's been "blessed", so that the Datum can be interpreted later.
 550          */
 551         if (variable->vartype != RECORDOID)
 552         {
 553                 HeapTupleHeaderSetTypeId(dtuple, variable->vartype);
 554                 HeapTupleHeaderSetTypMod(dtuple, variable->vartypmod);
 555         }
 556         else
 557         {
 558                 if (tupleDesc->tdtypeid == RECORDOID &&
 559                         tupleDesc->tdtypmod < 0)
 560                         assign_record_type_typmod(tupleDesc);
 561                 HeapTupleHeaderSetTypeId(dtuple, tupleDesc->tdtypeid);
 562                 HeapTupleHeaderSetTypMod(dtuple, tupleDesc->tdtypmod);
 563         }
 564
 565         return PointerGetDatum(dtuple);
 566 }
 567
 568 /* ----------------------------------------------------------------
 569  *              ExecEvalConst
 570  *
 571  *              Returns the value of a constant.
 572  *
 573  *              Note that for pass-by-ref datatypes, we return a pointer to the
 574  *              actual constant node.  This is one of the reasons why functions
 575  *              must treat their input arguments as read-only.
 576  * ----------------------------------------------------------------
 577  */
 578 static Datum
 579 ExecEvalConst(ExprState *exprstate, ExprContext *econtext,
 580                           bool *isNull, ExprDoneCond *isDone)
 581 {
 582         Const      *con = (Const *) exprstate->expr;
 583
 584         if (isDone)
 585                 *isDone = ExprSingleResult;
 586
 587         *isNull = con->constisnull;
 588         return con->constvalue;
 589 }
 590
 591 /* ----------------------------------------------------------------
 592  *              ExecEvalParam
 593  *
 594  *              Returns the value of a parameter.  A param node contains
 595  *              something like ($.name) and the expression context contains
 596  *              the current parameter bindings (name = "sam") (age = 34)...
 597  *              so our job is to find and return the appropriate datum ("sam").
 598  *
 599  *              Q: if we have a parameter ($.foo) without a binding, i.e.
 600  *                 there is no (foo = xxx) in the parameter list info,
 601  *                 is this a fatal error or should this be a "not available"
 602  *                 (in which case we could return NULL)?        -cim 10/13/89
 603  * ----------------------------------------------------------------
 604  */
 605 static Datum
 606 ExecEvalParam(ExprState *exprstate, ExprContext *econtext,
 607                           bool *isNull, ExprDoneCond *isDone)
 608 {
 609         Param      *expression = (Param *) exprstate->expr;
 610         int                     thisParamId = expression->paramid;
 611
 612         if (isDone)
 613                 *isDone = ExprSingleResult;
 614
 615         if (expression->paramkind == PARAM_EXEC)
 616         {
 617                 /*
 618                  * PARAM_EXEC params (internal executor parameters) are stored in the
 619                  * ecxt_param_exec_vals array, and can be accessed by array index.
 620                  */
 621                 ParamExecData *prm;
 622
 623                 prm = &(econtext->ecxt_param_exec_vals[thisParamId]);
 624                 if (prm->execPlan != NULL)
 625                 {
 626                         /* Parameter not evaluated yet, so go do it */
 627                         ExecSetParamPlan(prm->execPlan, econtext);
 628                         /* ExecSetParamPlan should have processed this param... */
 629                         Assert(prm->execPlan == NULL);
 630                 }
 631                 *isNull = prm->isnull;
 632                 return prm->value;
 633         }
 634         else
 635         {
 636                 /*
 637                  * PARAM_EXTERN parameters must be sought in ecxt_param_list_info.
 638                  */
 639                 ParamListInfo paramInfo = econtext->ecxt_param_list_info;
 640
 641                 Assert(expression->paramkind == PARAM_EXTERN);
 642                 if (paramInfo &&
 643                         thisParamId > 0 && thisParamId <= paramInfo->numParams)
 644                 {
 645                         ParamExternData *prm = &paramInfo->params[thisParamId - 1];
 646
 647                         if (OidIsValid(prm->ptype))
 648                         {
 649                                 Assert(prm->ptype == expression->paramtype);
 650                                 *isNull = prm->isnull;
 651                                 return prm->value;
 652                         }
 653                 }
 654                 ereport(ERROR,
 655                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 656                                  errmsg("no value found for parameter %d", thisParamId)));
 657                 return (Datum) 0;               /* keep compiler quiet */
 658         }
 659 }
 660
 661
 662 /* ----------------------------------------------------------------
 663  *              ExecEvalOper / ExecEvalFunc support routines
 664  * ----------------------------------------------------------------
 665  */
 666
 667 /*
 668  *              GetAttributeByName
 669  *              GetAttributeByNum
 670  *
 671  *              These functions return the value of the requested attribute
 672  *              out of the given tuple Datum.
 673  *              C functions which take a tuple as an argument are expected
 674  *              to use these.  Ex: overpaid(EMP) might call GetAttributeByNum().
 675  *              Note: these are actually rather slow because they do a typcache
 676  *              lookup on each call.
 677  */
 678 Datum
 679 GetAttributeByNum(HeapTupleHeader tuple,
 680                                   AttrNumber attrno,
 681                                   bool *isNull)
 682 {
 683         Datum           result;
 684         Oid                     tupType;
 685         int32           tupTypmod;
 686         TupleDesc       tupDesc;
 687         HeapTupleData tmptup;
 688
 689         if (!AttributeNumberIsValid(attrno))
 690                 elog(ERROR, "invalid attribute number %d", attrno);
 691
 692         if (isNull == NULL)
 693                 elog(ERROR, "a NULL isNull pointer was passed");
 694
 695         if (tuple == NULL)
 696         {
 697                 /* Kinda bogus but compatible with old behavior... */
 698                 *isNull = true;
 699                 return (Datum) 0;
 700         }
 701
 702         tupType = HeapTupleHeaderGetTypeId(tuple);
 703         tupTypmod = HeapTupleHeaderGetTypMod(tuple);
 704         tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 705
 706         /*
 707          * heap_getattr needs a HeapTuple not a bare HeapTupleHeader.  We set all
 708          * the fields in the struct just in case user tries to inspect system
 709          * columns.
 710          */
 711         tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
 712         ItemPointerSetInvalid(&(tmptup.t_self));
 713         tmptup.t_tableOid = InvalidOid;
 714         tmptup.t_data = tuple;
 715
 716         result = heap_getattr(&tmptup,
 717                                                   attrno,
 718                                                   tupDesc,
 719                                                   isNull);
 720
 721         ReleaseTupleDesc(tupDesc);
 722
 723         return result;
 724 }
 725
 726 Datum
 727 GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
 728 {
 729         AttrNumber      attrno;
 730         Datum           result;
 731         Oid                     tupType;
 732         int32           tupTypmod;
 733         TupleDesc       tupDesc;
 734         HeapTupleData tmptup;
 735         int                     i;
 736
 737         if (attname == NULL)
 738                 elog(ERROR, "invalid attribute name");
 739
 740         if (isNull == NULL)
 741                 elog(ERROR, "a NULL isNull pointer was passed");
 742
 743         if (tuple == NULL)
 744         {
 745                 /* Kinda bogus but compatible with old behavior... */
 746                 *isNull = true;
 747                 return (Datum) 0;
 748         }
 749
 750         tupType = HeapTupleHeaderGetTypeId(tuple);
 751         tupTypmod = HeapTupleHeaderGetTypMod(tuple);
 752         tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 753
 754         attrno = InvalidAttrNumber;
 755         for (i = 0; i < tupDesc->natts; i++)
 756         {
 757                 if (namestrcmp(&(tupDesc->attrs[i]->attname), attname) == 0)
 758                 {
 759                         attrno = tupDesc->attrs[i]->attnum;
 760                         break;
 761                 }
 762         }
 763
 764         if (attrno == InvalidAttrNumber)
 765                 elog(ERROR, "attribute \"%s\" does not exist", attname);
 766
 767         /*
 768          * heap_getattr needs a HeapTuple not a bare HeapTupleHeader.  We set all
 769          * the fields in the struct just in case user tries to inspect system
 770          * columns.
 771          */
 772         tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
 773         ItemPointerSetInvalid(&(tmptup.t_self));
 774         tmptup.t_tableOid = InvalidOid;
 775         tmptup.t_data = tuple;
 776
 777         result = heap_getattr(&tmptup,
 778                                                   attrno,
 779                                                   tupDesc,
 780                                                   isNull);
 781
 782         ReleaseTupleDesc(tupDesc);
 783
 784         return result;
 785 }
 786
 787 /*
 788  * init_fcache - initialize a FuncExprState node during first use
 789  */
 790 void
 791 init_fcache(Oid foid, FuncExprState *fcache, MemoryContext fcacheCxt)
 792 {
 793         AclResult       aclresult;
 794
 795         /* Check permission to call function */
 796         aclresult = pg_proc_aclcheck(foid, GetUserId(), ACL_EXECUTE);
 797         if (aclresult != ACLCHECK_OK)
 798                 aclcheck_error(aclresult, ACL_KIND_PROC, get_func_name(foid));
 799
 800         /*
 801          * Safety check on nargs.  Under normal circumstances this should never
 802          * fail, as parser should check sooner.  But possibly it might fail if
 803          * server has been compiled with FUNC_MAX_ARGS smaller than some functions
 804          * declared in pg_proc?
 805          */
 806         if (list_length(fcache->args) > FUNC_MAX_ARGS)
 807                 ereport(ERROR,
 808                                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
 809                                  errmsg("cannot pass more than %d arguments to a function",
 810                                                 FUNC_MAX_ARGS)));
 811
 812         /* Set up the primary fmgr lookup information */
 813         fmgr_info_cxt(foid, &(fcache->func), fcacheCxt);
 814
 815         /* Initialize additional info */
 816         fcache->setArgsValid = false;
 817         fcache->shutdown_reg = false;
 818         fcache->func.fn_expr = (Node *) fcache->xprstate.expr;
 819 }
 820
 821 /*
 822  * callback function in case a FuncExpr returning a set needs to be shut down
 823  * before it has been run to completion
 824  */
 825 static void
 826 ShutdownFuncExpr(Datum arg)
 827 {
 828         FuncExprState *fcache = (FuncExprState *) DatumGetPointer(arg);
 829
 830         /* Clear any active set-argument state */
 831         fcache->setArgsValid = false;
 832
 833         /* execUtils will deregister the callback... */
 834         fcache->shutdown_reg = false;
 835 }
 836
 837 /*
 838  * get_cached_rowtype: utility function to lookup a rowtype tupdesc
 839  *
 840  * type_id, typmod: identity of the rowtype
 841  * cache_field: where to cache the TupleDesc pointer in expression state node
 842  *              (field must be initialized to NULL)
 843  * econtext: expression context we are executing in
 844  *
 845  * NOTE: because the shutdown callback will be called during plan rescan,
 846  * must be prepared to re-do this during any node execution; cannot call
 847  * just once during expression initialization
 848  */
 849 static TupleDesc
 850 get_cached_rowtype(Oid type_id, int32 typmod,
 851                                    TupleDesc *cache_field, ExprContext *econtext)
 852 {
 853         TupleDesc       tupDesc = *cache_field;
 854
 855         /* Do lookup if no cached value or if requested type changed */
 856         if (tupDesc == NULL ||
 857                 type_id != tupDesc->tdtypeid ||
 858                 typmod != tupDesc->tdtypmod)
 859         {
 860                 tupDesc = lookup_rowtype_tupdesc(type_id, typmod);
 861
 862                 if (*cache_field)
 863                 {
 864                         /* Release old tupdesc; but callback is already registered */
 865                         ReleaseTupleDesc(*cache_field);
 866                 }
 867                 else
 868                 {
 869                         /* Need to register shutdown callback to release tupdesc */
 870                         RegisterExprContextCallback(econtext,
 871                                                                                 ShutdownTupleDescRef,
 872                                                                                 PointerGetDatum(cache_field));
 873                 }
 874                 *cache_field = tupDesc;
 875         }
 876         return tupDesc;
 877 }
 878
 879 /*
 880  * Callback function to release a tupdesc refcount at expression tree shutdown
 881  */
 882 static void
 883 ShutdownTupleDescRef(Datum arg)
 884 {
 885         TupleDesc *cache_field = (TupleDesc *) DatumGetPointer(arg);
 886
 887         if (*cache_field)
 888                 ReleaseTupleDesc(*cache_field);
 889         *cache_field = NULL;
 890 }
 891
 892 /*
 893  * Evaluate arguments for a function.
 894  */
 895 static ExprDoneCond
 896 ExecEvalFuncArgs(FunctionCallInfo fcinfo,
 897                                  List *argList,
 898                                  ExprContext *econtext)
 899 {
 900         ExprDoneCond argIsDone;
 901         int                     i;
 902         ListCell   *arg;
 903
 904         argIsDone = ExprSingleResult;           /* default assumption */
 905
 906         i = 0;
 907         foreach(arg, argList)
 908         {
 909                 ExprState  *argstate = (ExprState *) lfirst(arg);
 910                 ExprDoneCond thisArgIsDone;
 911
 912                 fcinfo->arg[i] = ExecEvalExpr(argstate,
 913                                                                           econtext,
 914                                                                           &fcinfo->argnull[i],
 915                                                                           &thisArgIsDone);
 916
 917                 if (thisArgIsDone != ExprSingleResult)
 918                 {
 919                         /*
 920                          * We allow only one argument to have a set value; we'd need much
 921                          * more complexity to keep track of multiple set arguments (cf.
 922                          * ExecTargetList) and it doesn't seem worth it.
 923                          */
 924                         if (argIsDone != ExprSingleResult)
 925                                 ereport(ERROR,
 926                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 927                                                  errmsg("functions and operators can take at most one set argument")));
 928                         argIsDone = thisArgIsDone;
 929                 }
 930                 i++;
 931         }
 932
 933         fcinfo->nargs = i;
 934
 935         return argIsDone;
 936 }
 937
 938 /*
 939  *              ExecMakeFunctionResult
 940  *
 941  * Evaluate the arguments to a function and then the function itself.
 942  */
 943 Datum
 944 ExecMakeFunctionResult(FuncExprState *fcache,
 945                                            ExprContext *econtext,
 946                                            bool *isNull,
 947                                            ExprDoneCond *isDone)
 948 {
 949         List       *arguments = fcache->args;
 950         Datum           result;
 951         FunctionCallInfoData fcinfo;
 952         ReturnSetInfo rsinfo;           /* for functions returning sets */
 953         ExprDoneCond argDone;
 954         bool            hasSetArg;
 955         int                     i;
 956
 957         /* Guard against stack overflow due to overly complex expressions */
 958         check_stack_depth();
 959
 960         /*
 961          * arguments is a list of expressions to evaluate before passing to the
 962          * function manager.  We skip the evaluation if it was already done in the
 963          * previous call (ie, we are continuing the evaluation of a set-valued
 964          * function).  Otherwise, collect the current argument values into fcinfo.
 965          */
 966         if (!fcache->setArgsValid)
 967         {
 968                 /* Need to prep callinfo structure */
 969                 InitFunctionCallInfoData(fcinfo, &(fcache->func), 0, NULL, NULL);
 970                 argDone = ExecEvalFuncArgs(&fcinfo, arguments, econtext);
 971                 if (argDone == ExprEndResult)
 972                 {
 973                         /* input is an empty set, so return an empty set. */
 974                         *isNull = true;
 975                         if (isDone)
 976                                 *isDone = ExprEndResult;
 977                         else
 978                                 ereport(ERROR,
 979                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 980                                                  errmsg("set-valued function called in context that cannot accept a set")));
 981                         return (Datum) 0;
 982                 }
 983                 hasSetArg = (argDone != ExprSingleResult);
 984         }
 985         else
 986         {
 987                 /* Copy callinfo from previous evaluation */
 988                 memcpy(&fcinfo, &fcache->setArgs, sizeof(fcinfo));
 989                 hasSetArg = fcache->setHasSetArg;
 990                 /* Reset flag (we may set it again below) */
 991                 fcache->setArgsValid = false;
 992         }
 993
 994         /*
 995          * If function returns set, prepare a resultinfo node for communication
 996          */
 997         if (fcache->func.fn_retset)
 998         {
 999                 fcinfo.resultinfo = (Node *) &rsinfo;
1000                 rsinfo.type = T_ReturnSetInfo;
1001                 rsinfo.econtext = econtext;
1002                 rsinfo.expectedDesc = NULL;
1003                 rsinfo.allowedModes = (int) SFRM_ValuePerCall;
1004                 rsinfo.returnMode = SFRM_ValuePerCall;
1005                 /* isDone is filled below */
1006                 rsinfo.setResult = NULL;
1007                 rsinfo.setDesc = NULL;
1008         }
1009
1010         /*
1011          * now return the value gotten by calling the function manager, passing
1012          * the function the evaluated parameter values.
1013          */
1014         if (fcache->func.fn_retset || hasSetArg)
1015         {
1016                 /*
1017                  * We need to return a set result.      Complain if caller not ready to
1018                  * accept one.
1019                  */
1020                 if (isDone == NULL)
1021                         ereport(ERROR,
1022                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1023                                          errmsg("set-valued function called in context that cannot accept a set")));
1024
1025                 /*
1026                  * This loop handles the situation where we have both a set argument
1027                  * and a set-valued function.  Once we have exhausted the function's
1028                  * value(s) for a particular argument value, we have to get the next
1029                  * argument value and start the function over again. We might have to
1030                  * do it more than once, if the function produces an empty result set
1031                  * for a particular input value.
1032                  */
1033                 for (;;)
1034                 {
1035                         /*
1036                          * If function is strict, and there are any NULL arguments, skip
1037                          * calling the function (at least for this set of args).
1038                          */
1039                         bool            callit = true;
1040
1041                         if (fcache->func.fn_strict)
1042                         {
1043                                 for (i = 0; i < fcinfo.nargs; i++)
1044                                 {
1045                                         if (fcinfo.argnull[i])
1046                                         {
1047                                                 callit = false;
1048                                                 break;
1049                                         }
1050                                 }
1051                         }
1052
1053                         if (callit)
1054                         {
1055                                 fcinfo.isnull = false;
1056                                 rsinfo.isDone = ExprSingleResult;
1057                                 result = FunctionCallInvoke(&fcinfo);
1058                                 *isNull = fcinfo.isnull;
1059                                 *isDone = rsinfo.isDone;
1060                         }
1061                         else
1062                         {
1063                                 result = (Datum) 0;
1064                                 *isNull = true;
1065                                 *isDone = ExprEndResult;
1066                         }
1067
1068                         if (*isDone != ExprEndResult)
1069                         {
1070                                 /*
1071                                  * Got a result from current argument.  If function itself
1072                                  * returns set, save the current argument values to re-use on
1073                                  * the next call.
1074                                  */
1075                                 if (fcache->func.fn_retset && *isDone == ExprMultipleResult)
1076                                 {
1077                                         memcpy(&fcache->setArgs, &fcinfo, sizeof(fcinfo));
1078                                         fcache->setHasSetArg = hasSetArg;
1079                                         fcache->setArgsValid = true;
1080                                         /* Register cleanup callback if we didn't already */
1081                                         if (!fcache->shutdown_reg)
1082                                         {
1083                                                 RegisterExprContextCallback(econtext,
1084                                                                                                         ShutdownFuncExpr,
1085                                                                                                         PointerGetDatum(fcache));
1086                                                 fcache->shutdown_reg = true;
1087                                         }
1088                                 }
1089
1090                                 /*
1091                                  * Make sure we say we are returning a set, even if the
1092                                  * function itself doesn't return sets.
1093                                  */
1094                                 if (hasSetArg)
1095                                         *isDone = ExprMultipleResult;
1096                                 break;
1097                         }
1098
1099                         /* Else, done with this argument */
1100                         if (!hasSetArg)
1101                                 break;                  /* input not a set, so done */
1102
1103                         /* Re-eval args to get the next element of the input set */
1104                         argDone = ExecEvalFuncArgs(&fcinfo, arguments, econtext);
1105
1106                         if (argDone != ExprMultipleResult)
1107                         {
1108                                 /* End of argument set, so we're done. */
1109                                 *isNull = true;
1110                                 *isDone = ExprEndResult;
1111                                 result = (Datum) 0;
1112                                 break;
1113                         }
1114
1115                         /*
1116                          * If we reach here, loop around to run the function on the new
1117                          * argument.
1118                          */
1119                 }
1120         }
1121         else
1122         {
1123                 /*
1124                  * Non-set case: much easier.
1125                  *
1126                  * We change the ExprState function pointer to use the simpler
1127                  * ExecMakeFunctionResultNoSets on subsequent calls.  This amounts to
1128                  * assuming that no argument can return a set if it didn't do so the
1129                  * first time.
1130                  */
1131                 fcache->xprstate.evalfunc = (ExprStateEvalFunc) ExecMakeFunctionResultNoSets;
1132
1133                 if (isDone)
1134                         *isDone = ExprSingleResult;
1135
1136                 /*
1137                  * If function is strict, and there are any NULL arguments, skip
1138                  * calling the function and return NULL.
1139                  */
1140                 if (fcache->func.fn_strict)
1141                 {
1142                         for (i = 0; i < fcinfo.nargs; i++)
1143                         {
1144                                 if (fcinfo.argnull[i])
1145                                 {
1146                                         *isNull = true;
1147                                         return (Datum) 0;
1148                                 }
1149                         }
1150                 }
1151                 fcinfo.isnull = false;
1152                 result = FunctionCallInvoke(&fcinfo);
1153                 *isNull = fcinfo.isnull;
1154         }
1155
1156         return result;
1157 }
1158
1159 /*
1160  *              ExecMakeFunctionResultNoSets
1161  *
1162  * Simplified version of ExecMakeFunctionResult that can only handle
1163  * non-set cases.  Hand-tuned for speed.
1164  */
1165 static Datum
1166 ExecMakeFunctionResultNoSets(FuncExprState *fcache,
1167                                                          ExprContext *econtext,
1168                                                          bool *isNull,
1169                                                          ExprDoneCond *isDone)
1170 {
1171         ListCell   *arg;
1172         Datum           result;
1173         FunctionCallInfoData fcinfo;
1174         int                     i;
1175
1176         /* Guard against stack overflow due to overly complex expressions */
1177         check_stack_depth();
1178
1179         if (isDone)
1180                 *isDone = ExprSingleResult;
1181
1182         /* inlined, simplified version of ExecEvalFuncArgs */
1183         i = 0;
1184         foreach(arg, fcache->args)
1185         {
1186                 ExprState  *argstate = (ExprState *) lfirst(arg);
1187
1188                 fcinfo.arg[i] = ExecEvalExpr(argstate,
1189                                                                          econtext,
1190                                                                          &fcinfo.argnull[i],
1191                                                                          NULL);
1192                 i++;
1193         }
1194
1195         InitFunctionCallInfoData(fcinfo, &(fcache->func), i, NULL, NULL);
1196
1197         /*
1198          * If function is strict, and there are any NULL arguments, skip calling
1199          * the function and return NULL.
1200          */
1201         if (fcache->func.fn_strict)
1202         {
1203                 while (--i >= 0)
1204                 {
1205                         if (fcinfo.argnull[i])
1206                         {
1207                                 *isNull = true;
1208                                 return (Datum) 0;
1209                         }
1210                 }
1211         }
1212         /* fcinfo.isnull = false; */    /* handled by InitFunctionCallInfoData */
1213         result = FunctionCallInvoke(&fcinfo);
1214         *isNull = fcinfo.isnull;
1215
1216         return result;
1217 }
1218
1219
1220 /*
1221  *              ExecMakeTableFunctionResult
1222  *
1223  * Evaluate a table function, producing a materialized result in a Tuplestore
1224  * object.      *returnDesc is set to the tupledesc actually returned by the
1225  * function, or NULL if it didn't provide one.
1226  */
1227 Tuplestorestate *
1228 ExecMakeTableFunctionResult(ExprState *funcexpr,
1229                                                         ExprContext *econtext,
1230                                                         TupleDesc expectedDesc,
1231                                                         TupleDesc *returnDesc)
1232 {
1233         Tuplestorestate *tupstore = NULL;
1234         TupleDesc       tupdesc = NULL;
1235         Oid                     funcrettype;
1236         bool            returnsTuple;
1237         bool            returnsSet = false;
1238         FunctionCallInfoData fcinfo;
1239         ReturnSetInfo rsinfo;
1240         HeapTupleData tmptup;
1241         MemoryContext callerContext;
1242         MemoryContext oldcontext;
1243         bool            direct_function_call;
1244         bool            first_time = true;
1245
1246         callerContext = CurrentMemoryContext;
1247
1248         funcrettype = exprType((Node *) funcexpr->expr);
1249
1250         returnsTuple = (funcrettype == RECORDOID ||
1251                                         get_typtype(funcrettype) == 'c');
1252
1253         /*
1254          * Prepare a resultinfo node for communication.  We always do this even if
1255          * not expecting a set result, so that we can pass expectedDesc.  In the
1256          * generic-expression case, the expression doesn't actually get to see the
1257          * resultinfo, but set it up anyway because we use some of the fields as
1258          * our own state variables.
1259          */
1260         InitFunctionCallInfoData(fcinfo, NULL, 0, NULL, (Node *) &rsinfo);
1261         rsinfo.type = T_ReturnSetInfo;
1262         rsinfo.econtext = econtext;
1263         rsinfo.expectedDesc = expectedDesc;
1264         rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize);
1265         rsinfo.returnMode = SFRM_ValuePerCall;
1266         /* isDone is filled below */
1267         rsinfo.setResult = NULL;
1268         rsinfo.setDesc = NULL;
1269
1270         /*
1271          * Normally the passed expression tree will be a FuncExprState, since the
1272          * grammar only allows a function call at the top level of a table
1273          * function reference.  However, if the function doesn't return set then
1274          * the planner might have replaced the function call via constant-folding
1275          * or inlining.  So if we see any other kind of expression node, execute
1276          * it via the general ExecEvalExpr() code; the only difference is that we
1277          * don't get a chance to pass a special ReturnSetInfo to any functions
1278          * buried in the expression.
1279          */
1280         if (funcexpr && IsA(funcexpr, FuncExprState) &&
1281                 IsA(funcexpr->expr, FuncExpr))
1282         {
1283                 FuncExprState *fcache = (FuncExprState *) funcexpr;
1284                 ExprDoneCond argDone;
1285
1286                 /*
1287                  * This path is similar to ExecMakeFunctionResult.
1288                  */
1289                 direct_function_call = true;
1290
1291                 /*
1292                  * Initialize function cache if first time through
1293                  */
1294                 if (fcache->func.fn_oid == InvalidOid)
1295                 {
1296                         FuncExpr   *func = (FuncExpr *) fcache->xprstate.expr;
1297
1298                         init_fcache(func->funcid, fcache, econtext->ecxt_per_query_memory);
1299                 }
1300                 returnsSet = fcache->func.fn_retset;
1301
1302                 /*
1303                  * Evaluate the function's argument list.
1304                  *
1305                  * Note: ideally, we'd do this in the per-tuple context, but then the
1306                  * argument values would disappear when we reset the context in the
1307                  * inner loop.  So do it in caller context.  Perhaps we should make a
1308                  * separate context just to hold the evaluated arguments?
1309                  */
1310                 fcinfo.flinfo = &(fcache->func);
1311                 argDone = ExecEvalFuncArgs(&fcinfo, fcache->args, econtext);
1312                 /* We don't allow sets in the arguments of the table function */
1313                 if (argDone != ExprSingleResult)
1314                         ereport(ERROR,
1315                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1316                                          errmsg("set-valued function called in context that cannot accept a set")));
1317
1318                 /*
1319                  * If function is strict, and there are any NULL arguments, skip
1320                  * calling the function and act like it returned NULL (or an empty
1321                  * set, in the returns-set case).
1322                  */
1323                 if (fcache->func.fn_strict)
1324                 {
1325                         int                     i;
1326
1327                         for (i = 0; i < fcinfo.nargs; i++)
1328                         {
1329                                 if (fcinfo.argnull[i])
1330                                         goto no_function_result;
1331                         }
1332                 }
1333         }
1334         else
1335         {
1336                 /* Treat funcexpr as a generic expression */
1337                 direct_function_call = false;
1338         }
1339
1340         /*
1341          * Switch to short-lived context for calling the function or expression.
1342          */
1343         MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
1344
1345         /*
1346          * Loop to handle the ValuePerCall protocol (which is also the same
1347          * behavior needed in the generic ExecEvalExpr path).
1348          */
1349         for (;;)
1350         {
1351                 Datum           result;
1352                 HeapTuple       tuple;
1353
1354                 CHECK_FOR_INTERRUPTS();
1355
1356                 /*
1357                  * reset per-tuple memory context before each call of the function or
1358                  * expression. This cleans up any local memory the function may leak
1359                  * when called.
1360                  */
1361                 ResetExprContext(econtext);
1362
1363                 /* Call the function or expression one time */
1364                 if (direct_function_call)
1365                 {
1366                         fcinfo.isnull = false;
1367                         rsinfo.isDone = ExprSingleResult;
1368                         result = FunctionCallInvoke(&fcinfo);
1369                 }
1370                 else
1371                 {
1372                         result = ExecEvalExpr(funcexpr, econtext,
1373                                                                   &fcinfo.isnull, &rsinfo.isDone);
1374                 }
1375
1376                 /* Which protocol does function want to use? */
1377                 if (rsinfo.returnMode == SFRM_ValuePerCall)
1378                 {
1379                         /*
1380                          * Check for end of result set.
1381                          */
1382                         if (rsinfo.isDone == ExprEndResult)
1383                                 break;
1384
1385                         /*
1386                          * Can't do anything very useful with NULL rowtype values. For a
1387                          * function returning set, we consider this a protocol violation
1388                          * (but another alternative would be to just ignore the result and
1389                          * "continue" to get another row).      For a function not returning
1390                          * set, we fall out of the loop; we'll cons up an all-nulls result
1391                          * row below.
1392                          */
1393                         if (returnsTuple && fcinfo.isnull)
1394                         {
1395                                 if (!returnsSet)
1396                                         break;
1397                                 ereport(ERROR,
1398                                                 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
1399                                                  errmsg("function returning set of rows cannot return null value")));
1400                         }
1401
1402                         /*
1403                          * If first time through, build tupdesc and tuplestore for result
1404                          */
1405                         if (first_time)
1406                         {
1407                                 oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
1408                                 if (returnsTuple)
1409                                 {
1410                                         /*
1411                                          * Use the type info embedded in the rowtype Datum to look
1412                                          * up the needed tupdesc.  Make a copy for the query.
1413                                          */
1414                                         HeapTupleHeader td;
1415
1416                                         td = DatumGetHeapTupleHeader(result);
1417                                         tupdesc = lookup_rowtype_tupdesc_copy(HeapTupleHeaderGetTypeId(td),
1418                                                                                            HeapTupleHeaderGetTypMod(td));
1419                                 }
1420                                 else
1421                                 {
1422                                         /*
1423                                          * Scalar type, so make a single-column descriptor
1424                                          */
1425                                         tupdesc = CreateTemplateTupleDesc(1, false);
1426                                         TupleDescInitEntry(tupdesc,
1427                                                                            (AttrNumber) 1,
1428                                                                            "column",
1429                                                                            funcrettype,
1430                                                                            -1,
1431                                                                            0);
1432                                 }
1433                                 tupstore = tuplestore_begin_heap(true, false, work_mem);
1434                                 MemoryContextSwitchTo(oldcontext);
1435                                 rsinfo.setResult = tupstore;
1436                                 rsinfo.setDesc = tupdesc;
1437                         }
1438
1439                         /*
1440                          * Store current resultset item.
1441                          */
1442                         if (returnsTuple)
1443                         {
1444                                 HeapTupleHeader td;
1445
1446                                 td = DatumGetHeapTupleHeader(result);
1447
1448                                 /*
1449                                  * tuplestore_puttuple needs a HeapTuple not a bare
1450                                  * HeapTupleHeader, but it doesn't need all the fields.
1451                                  */
1452                                 tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
1453                                 tmptup.t_data = td;
1454                                 tuple = &tmptup;
1455                         }
1456                         else
1457                         {
1458                                 tuple = heap_form_tuple(tupdesc, &result, &fcinfo.isnull);
1459                         }
1460
1461                         oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
1462                         tuplestore_puttuple(tupstore, tuple);
1463                         MemoryContextSwitchTo(oldcontext);
1464
1465                         /*
1466                          * Are we done?
1467                          */
1468                         if (rsinfo.isDone != ExprMultipleResult)
1469                                 break;
1470                 }
1471                 else if (rsinfo.returnMode == SFRM_Materialize)
1472                 {
1473                         /* check we're on the same page as the function author */
1474                         if (!first_time || rsinfo.isDone != ExprSingleResult)
1475                                 ereport(ERROR,
1476                                                 (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
1477                                                  errmsg("table-function protocol for materialize mode was not followed")));
1478                         /* Done evaluating the set result */
1479                         break;
1480                 }
1481                 else
1482                         ereport(ERROR,
1483                                         (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
1484                                          errmsg("unrecognized table-function returnMode: %d",
1485                                                         (int) rsinfo.returnMode)));
1486
1487                 first_time = false;
1488         }
1489
1490 no_function_result:
1491
1492         /*
1493          * If we got nothing from the function (ie, an empty-set or NULL result),
1494          * we have to create the tuplestore to return, and if it's a
1495          * non-set-returning function then insert a single all-nulls row.
1496          */
1497         if (rsinfo.setResult == NULL)
1498         {
1499                 MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
1500                 tupstore = tuplestore_begin_heap(true, false, work_mem);
1501                 rsinfo.setResult = tupstore;
1502                 if (!returnsSet)
1503                 {
1504                         int                     natts = expectedDesc->natts;
1505                         Datum      *nulldatums;
1506                         bool       *nullflags;
1507                         HeapTuple       tuple;
1508
1509                         MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
1510                         nulldatums = (Datum *) palloc0(natts * sizeof(Datum));
1511                         nullflags = (bool *) palloc(natts * sizeof(bool));
1512                         memset(nullflags, true, natts * sizeof(bool));
1513                         tuple = heap_form_tuple(expectedDesc, nulldatums, nullflags);
1514                         MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
1515                         tuplestore_puttuple(tupstore, tuple);
1516                 }
1517         }
1518
1519         MemoryContextSwitchTo(callerContext);
1520
1521         /* The returned pointers are those in rsinfo */
1522         *returnDesc = rsinfo.setDesc;
1523         return rsinfo.setResult;
1524 }
1525
1526
1527 /* ----------------------------------------------------------------
1528  *              ExecEvalFunc
1529  *              ExecEvalOper
1530  *
1531  *              Evaluate the functional result of a list of arguments by calling the
1532  *              function manager.
1533  * ----------------------------------------------------------------
1534  */
1535
1536 /* ----------------------------------------------------------------
1537  *              ExecEvalFunc
1538  * ----------------------------------------------------------------
1539  */
1540 static Datum
1541 ExecEvalFunc(FuncExprState *fcache,
1542                          ExprContext *econtext,
1543                          bool *isNull,
1544                          ExprDoneCond *isDone)
1545 {
1546         /* This is called only the first time through */
1547         FuncExpr   *func = (FuncExpr *) fcache->xprstate.expr;
1548
1549         /* Initialize function lookup info */
1550         init_fcache(func->funcid, fcache, econtext->ecxt_per_query_memory);
1551
1552         /* Go directly to ExecMakeFunctionResult on subsequent uses */
1553         fcache->xprstate.evalfunc = (ExprStateEvalFunc) ExecMakeFunctionResult;
1554
1555         return ExecMakeFunctionResult(fcache, econtext, isNull, isDone);
1556 }
1557
1558 /* ----------------------------------------------------------------
1559  *              ExecEvalOper
1560  * ----------------------------------------------------------------
1561  */
1562 static Datum
1563 ExecEvalOper(FuncExprState *fcache,
1564                          ExprContext *econtext,
1565                          bool *isNull,
1566                          ExprDoneCond *isDone)
1567 {
1568         /* This is called only the first time through */
1569         OpExpr     *op = (OpExpr *) fcache->xprstate.expr;
1570
1571         /* Initialize function lookup info */
1572         init_fcache(op->opfuncid, fcache, econtext->ecxt_per_query_memory);
1573
1574         /* Go directly to ExecMakeFunctionResult on subsequent uses */
1575         fcache->xprstate.evalfunc = (ExprStateEvalFunc) ExecMakeFunctionResult;
1576
1577         return ExecMakeFunctionResult(fcache, econtext, isNull, isDone);
1578 }
1579
1580 /* ----------------------------------------------------------------
1581  *              ExecEvalDistinct
1582  *
1583  * IS DISTINCT FROM must evaluate arguments to determine whether
1584  * they are NULL; if either is NULL then the result is already
1585  * known. If neither is NULL, then proceed to evaluate the
1586  * function. Note that this is *always* derived from the equals
1587  * operator, but since we need special processing of the arguments
1588  * we can not simply reuse ExecEvalOper() or ExecEvalFunc().
1589  * ----------------------------------------------------------------
1590  */
1591 static Datum
1592 ExecEvalDistinct(FuncExprState *fcache,
1593                                  ExprContext *econtext,
1594                                  bool *isNull,
1595                                  ExprDoneCond *isDone)
1596 {
1597         Datum           result;
1598         FunctionCallInfoData fcinfo;
1599         ExprDoneCond argDone;
1600         List       *argList;
1601
1602         /* Set default values for result flags: non-null, not a set result */
1603         *isNull = false;
1604         if (isDone)
1605                 *isDone = ExprSingleResult;
1606
1607         /*
1608          * Initialize function cache if first time through
1609          */
1610         if (fcache->func.fn_oid == InvalidOid)
1611         {
1612                 DistinctExpr *op = (DistinctExpr *) fcache->xprstate.expr;
1613
1614                 init_fcache(op->opfuncid, fcache, econtext->ecxt_per_query_memory);
1615                 Assert(!fcache->func.fn_retset);
1616         }
1617
1618         /*
1619          * extract info from fcache
1620          */
1621         argList = fcache->args;
1622
1623         /* Need to prep callinfo structure */
1624         InitFunctionCallInfoData(fcinfo, &(fcache->func), 0, NULL, NULL);
1625         argDone = ExecEvalFuncArgs(&fcinfo, argList, econtext);
1626         if (argDone != ExprSingleResult)
1627                 ereport(ERROR,
1628                                 (errcode(ERRCODE_DATATYPE_MISMATCH),
1629                                  errmsg("IS DISTINCT FROM does not support set arguments")));
1630         Assert(fcinfo.nargs == 2);
1631
1632         if (fcinfo.argnull[0] && fcinfo.argnull[1])
1633         {
1634                 /* Both NULL? Then is not distinct... */
1635                 result = BoolGetDatum(FALSE);
1636         }
1637         else if (fcinfo.argnull[0] || fcinfo.argnull[1])
1638         {
1639                 /* Only one is NULL? Then is distinct... */
1640                 result = BoolGetDatum(TRUE);
1641         }
1642         else
1643         {
1644                 fcinfo.isnull = false;
1645                 result = FunctionCallInvoke(&fcinfo);
1646                 *isNull = fcinfo.isnull;
1647                 /* Must invert result of "=" */
1648                 result = BoolGetDatum(!DatumGetBool(result));
1649         }
1650
1651         return result;
1652 }
1653
1654 /*
1655  * ExecEvalScalarArrayOp
1656  *
1657  * Evaluate "scalar op ANY/ALL (array)".  The operator always yields boolean,
1658  * and we combine the results across all array elements using OR and AND
1659  * (for ANY and ALL respectively).      Of course we short-circuit as soon as
1660  * the result is known.
1661  */
1662 static Datum
1663 ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
1664                                           ExprContext *econtext,
1665                                           bool *isNull, ExprDoneCond *isDone)
1666 {
1667         ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) sstate->fxprstate.xprstate.expr;
1668         bool            useOr = opexpr->useOr;
1669         ArrayType  *arr;
1670         int                     nitems;
1671         Datum           result;
1672         bool            resultnull;
1673         FunctionCallInfoData fcinfo;
1674         ExprDoneCond argDone;
1675         int                     i;
1676         int16           typlen;
1677         bool            typbyval;
1678         char            typalign;
1679         char       *s;
1680         bits8      *bitmap;
1681         int                     bitmask;
1682
1683         /* Set default values for result flags: non-null, not a set result */
1684         *isNull = false;
1685         if (isDone)
1686                 *isDone = ExprSingleResult;
1687
1688         /*
1689          * Initialize function cache if first time through
1690          */
1691         if (sstate->fxprstate.func.fn_oid == InvalidOid)
1692         {
1693                 init_fcache(opexpr->opfuncid, &sstate->fxprstate,
1694                                         econtext->ecxt_per_query_memory);
1695                 Assert(!sstate->fxprstate.func.fn_retset);
1696         }
1697
1698         /* Need to prep callinfo structure */
1699         InitFunctionCallInfoData(fcinfo, &(sstate->fxprstate.func), 0, NULL, NULL);
1700         argDone = ExecEvalFuncArgs(&fcinfo, sstate->fxprstate.args, econtext);
1701         if (argDone != ExprSingleResult)
1702                 ereport(ERROR,
1703                                 (errcode(ERRCODE_DATATYPE_MISMATCH),
1704                            errmsg("op ANY/ALL (array) does not support set arguments")));
1705         Assert(fcinfo.nargs == 2);
1706
1707         /*
1708          * If the array is NULL then we return NULL --- it's not very meaningful
1709          * to do anything else, even if the operator isn't strict.
1710          */
1711         if (fcinfo.argnull[1])
1712         {
1713                 *isNull = true;
1714                 return (Datum) 0;
1715         }
1716         /* Else okay to fetch and detoast the array */
1717         arr = DatumGetArrayTypeP(fcinfo.arg[1]);
1718
1719         /*
1720          * If the array is empty, we return either FALSE or TRUE per the useOr
1721          * flag.  This is correct even if the scalar is NULL; since we would
1722          * evaluate the operator zero times, it matters not whether it would want
1723          * to return NULL.
1724          */
1725         nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
1726         if (nitems <= 0)
1727                 return BoolGetDatum(!useOr);
1728
1729         /*
1730          * If the scalar is NULL, and the function is strict, return NULL; no
1731          * point in iterating the loop.
1732          */
1733         if (fcinfo.argnull[0] && sstate->fxprstate.func.fn_strict)
1734         {
1735                 *isNull = true;
1736                 return (Datum) 0;
1737         }
1738
1739         /*
1740          * We arrange to look up info about the element type only once per series
1741          * of calls, assuming the element type doesn't change underneath us.
1742          */
1743         if (sstate->element_type != ARR_ELEMTYPE(arr))
1744         {
1745                 get_typlenbyvalalign(ARR_ELEMTYPE(arr),
1746                                                          &sstate->typlen,
1747                                                          &sstate->typbyval,
1748                                                          &sstate->typalign);
1749                 sstate->element_type = ARR_ELEMTYPE(arr);
1750         }
1751         typlen = sstate->typlen;
1752         typbyval = sstate->typbyval;
1753         typalign = sstate->typalign;
1754
1755         result = BoolGetDatum(!useOr);
1756         resultnull = false;
1757
1758         /* Loop over the array elements */
1759         s = (char *) ARR_DATA_PTR(arr);
1760         bitmap = ARR_NULLBITMAP(arr);
1761         bitmask = 1;
1762
1763         for (i = 0; i < nitems; i++)
1764         {
1765                 Datum           elt;
1766                 Datum           thisresult;
1767
1768                 /* Get array element, checking for NULL */
1769                 if (bitmap && (*bitmap & bitmask) == 0)
1770                 {
1771                         fcinfo.arg[1] = (Datum) 0;
1772                         fcinfo.argnull[1] = true;
1773                 }
1774                 else
1775                 {
1776                         elt = fetch_att(s, typbyval, typlen);
1777                         s = att_addlength(s, typlen, PointerGetDatum(s));
1778                         s = (char *) att_align(s, typalign);
1779                         fcinfo.arg[1] = elt;
1780                         fcinfo.argnull[1] = false;
1781                 }
1782
1783                 /* Call comparison function */
1784                 if (fcinfo.argnull[1] && sstate->fxprstate.func.fn_strict)
1785                 {
1786                         fcinfo.isnull = true;
1787                         thisresult = (Datum) 0;
1788                 }
1789                 else
1790                 {
1791                         fcinfo.isnull = false;
1792                         thisresult = FunctionCallInvoke(&fcinfo);
1793                 }
1794
1795                 /* Combine results per OR or AND semantics */
1796                 if (fcinfo.isnull)
1797                         resultnull = true;
1798                 else if (useOr)
1799                 {
1800                         if (DatumGetBool(thisresult))
1801                         {
1802                                 result = BoolGetDatum(true);
1803                                 resultnull = false;
1804                                 break;                  /* needn't look at any more elements */
1805                         }
1806                 }
1807                 else
1808                 {
1809                         if (!DatumGetBool(thisresult))
1810                         {
1811                                 result = BoolGetDatum(false);
1812                                 resultnull = false;
1813                                 break;                  /* needn't look at any more elements */
1814                         }
1815                 }
1816
1817                 /* advance bitmap pointer if any */
1818                 if (bitmap)
1819                 {
1820                         bitmask <<= 1;
1821                         if (bitmask == 0x100)
1822                         {
1823                                 bitmap++;
1824                                 bitmask = 1;
1825                         }
1826                 }
1827         }
1828
1829         *isNull = resultnull;
1830         return result;
1831 }
1832
1833 /* ----------------------------------------------------------------
1834  *              ExecEvalNot
1835  *              ExecEvalOr
1836  *              ExecEvalAnd
1837  *
1838  *              Evaluate boolean expressions, with appropriate short-circuiting.
1839  *
1840  *              The query planner reformulates clause expressions in the
1841  *              qualification to conjunctive normal form.  If we ever get
1842  *              an AND to evaluate, we can be sure that it's not a top-level
1843  *              clause in the qualification, but appears lower (as a function
1844  *              argument, for example), or in the target list.  Not that you
1845  *              need to know this, mind you...
1846  * ----------------------------------------------------------------
1847  */
1848 static Datum
1849 ExecEvalNot(BoolExprState *notclause, ExprContext *econtext,
1850                         bool *isNull, ExprDoneCond *isDone)
1851 {
1852         ExprState  *clause = linitial(notclause->args);
1853         Datum           expr_value;
1854
1855         if (isDone)
1856                 *isDone = ExprSingleResult;
1857
1858         expr_value = ExecEvalExpr(clause, econtext, isNull, NULL);
1859
1860         /*
1861          * if the expression evaluates to null, then we just cascade the null back
1862          * to whoever called us.
1863          */
1864         if (*isNull)
1865                 return expr_value;
1866
1867         /*
1868          * evaluation of 'not' is simple.. expr is false, then return 'true' and
1869          * vice versa.
1870          */
1871         return BoolGetDatum(!DatumGetBool(expr_value));
1872 }
1873
1874 /* ----------------------------------------------------------------
1875  *              ExecEvalOr
1876  * ----------------------------------------------------------------
1877  */
1878 static Datum
1879 ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext,
1880                    bool *isNull, ExprDoneCond *isDone)
1881 {
1882         List       *clauses = orExpr->args;
1883         ListCell   *clause;
1884         bool            AnyNull;
1885
1886         if (isDone)
1887                 *isDone = ExprSingleResult;
1888
1889         AnyNull = false;
1890
1891         /*
1892          * If any of the clauses is TRUE, the OR result is TRUE regardless of the
1893          * states of the rest of the clauses, so we can stop evaluating and return
1894          * TRUE immediately.  If none are TRUE and one or more is NULL, we return
1895          * NULL; otherwise we return FALSE.  This makes sense when you interpret
1896          * NULL as "don't know": if we have a TRUE then the OR is TRUE even if we
1897          * aren't sure about some of the other inputs. If all the known inputs are
1898          * FALSE, but we have one or more "don't knows", then we have to report
1899          * that we "don't know" what the OR's result should be --- perhaps one of
1900          * the "don't knows" would have been TRUE if we'd known its value.  Only
1901          * when all the inputs are known to be FALSE can we state confidently that
1902          * the OR's result is FALSE.
1903          */
1904         foreach(clause, clauses)
1905         {
1906                 ExprState  *clausestate = (ExprState *) lfirst(clause);
1907                 Datum           clause_value;
1908
1909                 clause_value = ExecEvalExpr(clausestate, econtext, isNull, NULL);
1910
1911                 /*
1912                  * if we have a non-null true result, then return it.
1913                  */
1914                 if (*isNull)
1915                         AnyNull = true;         /* remember we got a null */
1916                 else if (DatumGetBool(clause_value))
1917                         return clause_value;
1918         }
1919
1920         /* AnyNull is true if at least one clause evaluated to NULL */
1921         *isNull = AnyNull;
1922         return BoolGetDatum(false);
1923 }
1924
1925 /* ----------------------------------------------------------------
1926  *              ExecEvalAnd
1927  * ----------------------------------------------------------------
1928  */
1929 static Datum
1930 ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext,
1931                         bool *isNull, ExprDoneCond *isDone)
1932 {
1933         List       *clauses = andExpr->args;
1934         ListCell   *clause;
1935         bool            AnyNull;
1936
1937         if (isDone)
1938                 *isDone = ExprSingleResult;
1939
1940         AnyNull = false;
1941
1942         /*
1943          * If any of the clauses is FALSE, the AND result is FALSE regardless of
1944          * the states of the rest of the clauses, so we can stop evaluating and
1945          * return FALSE immediately.  If none are FALSE and one or more is NULL,
1946          * we return NULL; otherwise we return TRUE.  This makes sense when you
1947          * interpret NULL as "don't know", using the same sort of reasoning as for
1948          * OR, above.
1949          */
1950
1951         foreach(clause, clauses)
1952         {
1953                 ExprState  *clausestate = (ExprState *) lfirst(clause);
1954                 Datum           clause_value;
1955
1956                 clause_value = ExecEvalExpr(clausestate, econtext, isNull, NULL);
1957
1958                 /*
1959                  * if we have a non-null false result, then return it.
1960                  */
1961                 if (*isNull)
1962                         AnyNull = true;         /* remember we got a null */
1963                 else if (!DatumGetBool(clause_value))
1964                         return clause_value;
1965         }
1966
1967         /* AnyNull is true if at least one clause evaluated to NULL */
1968         *isNull = AnyNull;
1969         return BoolGetDatum(!AnyNull);
1970 }
1971
1972 /* ----------------------------------------------------------------
1973  *              ExecEvalConvertRowtype
1974  *
1975  *              Evaluate a rowtype coercion operation.  This may require
1976  *              rearranging field positions.
1977  * ----------------------------------------------------------------
1978  */
1979 static Datum
1980 ExecEvalConvertRowtype(ConvertRowtypeExprState *cstate,
1981                                            ExprContext *econtext,
1982                                            bool *isNull, ExprDoneCond *isDone)
1983 {
1984         ConvertRowtypeExpr *convert = (ConvertRowtypeExpr *) cstate->xprstate.expr;
1985         HeapTuple       result;
1986         Datum           tupDatum;
1987         HeapTupleHeader tuple;
1988         HeapTupleData tmptup;
1989         AttrNumber *attrMap;
1990         Datum      *invalues;
1991         bool       *inisnull;
1992         Datum      *outvalues;
1993         bool       *outisnull;
1994         int                     i;
1995         int                     outnatts;
1996
1997         tupDatum = ExecEvalExpr(cstate->arg, econtext, isNull, isDone);
1998
1999         /* this test covers the isDone exception too: */
2000         if (*isNull)
2001                 return tupDatum;
2002
2003         tuple = DatumGetHeapTupleHeader(tupDatum);
2004
2005         /* Lookup tupdescs if first time through or after rescan */
2006         if (cstate->indesc == NULL)
2007                 get_cached_rowtype(exprType((Node *) convert->arg), -1,
2008                                                    &cstate->indesc, econtext);
2009         if (cstate->outdesc == NULL)
2010                 get_cached_rowtype(convert->resulttype, -1,
2011                                                    &cstate->outdesc, econtext);
2012
2013         Assert(HeapTupleHeaderGetTypeId(tuple) == cstate->indesc->tdtypeid);
2014         Assert(HeapTupleHeaderGetTypMod(tuple) == cstate->indesc->tdtypmod);
2015
2016         /* if first time through, initialize */
2017         if (cstate->attrMap == NULL)
2018         {
2019                 MemoryContext   old_cxt;
2020                 int             n;
2021
2022                 /* allocate state in long-lived memory context */
2023                 old_cxt = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
2024
2025                 /* prepare map from old to new attribute numbers */
2026                 n = cstate->outdesc->natts;
2027                 cstate->attrMap = (AttrNumber *) palloc0(n * sizeof(AttrNumber));
2028                 for (i = 0; i < n; i++)
2029                 {
2030                         Form_pg_attribute att = cstate->outdesc->attrs[i];
2031                         char       *attname;
2032                         Oid                     atttypid;
2033                         int32           atttypmod;
2034                         int                     j;
2035
2036                         if (att->attisdropped)
2037                                 continue;               /* attrMap[i] is already 0 */
2038                         attname = NameStr(att->attname);
2039                         atttypid = att->atttypid;
2040                         atttypmod = att->atttypmod;
2041                         for (j = 0; j < cstate->indesc->natts; j++)
2042                         {
2043                                 att = cstate->indesc->attrs[j];
2044                                 if (att->attisdropped)
2045                                         continue;
2046                                 if (strcmp(attname, NameStr(att->attname)) == 0)
2047                                 {
2048                                         /* Found it, check type */
2049                                         if (atttypid != att->atttypid || atttypmod != att->atttypmod)
2050                                                 elog(ERROR, "attribute \"%s\" of type %s does not match corresponding attribute of type %s",
2051                                                          attname,
2052                                                          format_type_be(cstate->indesc->tdtypeid),
2053                                                          format_type_be(cstate->outdesc->tdtypeid));
2054                                         cstate->attrMap[i] = (AttrNumber) (j + 1);
2055                                         break;
2056                                 }
2057                         }
2058                         if (cstate->attrMap[i] == 0)
2059                                 elog(ERROR, "attribute \"%s\" of type %s does not exist",
2060                                          attname,
2061                                          format_type_be(cstate->indesc->tdtypeid));
2062                 }
2063                 /* preallocate workspace for Datum arrays */
2064                 n = cstate->indesc->natts + 1;  /* +1 for NULL */
2065                 cstate->invalues = (Datum *) palloc(n * sizeof(Datum));
2066                 cstate->inisnull = (bool *) palloc(n * sizeof(bool));
2067                 n = cstate->outdesc->natts;
2068                 cstate->outvalues = (Datum *) palloc(n * sizeof(Datum));
2069                 cstate->outisnull = (bool *) palloc(n * sizeof(bool));
2070
2071                 MemoryContextSwitchTo(old_cxt);
2072         }
2073
2074         attrMap = cstate->attrMap;
2075         invalues = cstate->invalues;
2076         inisnull = cstate->inisnull;
2077         outvalues = cstate->outvalues;
2078         outisnull = cstate->outisnull;
2079         outnatts = cstate->outdesc->natts;
2080
2081         /*
2082          * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader.
2083          */
2084         tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
2085         tmptup.t_data = tuple;
2086
2087         /*
2088          * Extract all the values of the old tuple, offsetting the arrays so that
2089          * invalues[0] is NULL and invalues[1] is the first source attribute; this
2090          * exactly matches the numbering convention in attrMap.
2091          */
2092         heap_deform_tuple(&tmptup, cstate->indesc, invalues + 1, inisnull + 1);
2093         invalues[0] = (Datum) 0;
2094         inisnull[0] = true;
2095
2096         /*
2097          * Transpose into proper fields of the new tuple.
2098          */
2099         for (i = 0; i < outnatts; i++)
2100         {
2101                 int                     j = attrMap[i];
2102
2103                 outvalues[i] = invalues[j];
2104                 outisnull[i] = inisnull[j];
2105         }
2106
2107         /*
2108          * Now form the new tuple.
2109          */
2110         result = heap_form_tuple(cstate->outdesc, outvalues, outisnull);
2111
2112         return HeapTupleGetDatum(result);
2113 }
2114
2115 /* ----------------------------------------------------------------
2116  *              ExecEvalCase
2117  *
2118  *              Evaluate a CASE clause. Will have boolean expressions
2119  *              inside the WHEN clauses, and will have expressions
2120  *              for results.
2121  *              - thomas 1998-11-09
2122  * ----------------------------------------------------------------
2123  */
2124 static Datum
2125 ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
2126                          bool *isNull, ExprDoneCond *isDone)
2127 {
2128         List       *clauses = caseExpr->args;
2129         ListCell   *clause;
2130         Datum           save_datum;
2131         bool            save_isNull;
2132
2133         if (isDone)
2134                 *isDone = ExprSingleResult;
2135
2136         /*
2137          * If there's a test expression, we have to evaluate it and save the value
2138          * where the CaseTestExpr placeholders can find it. We must save and
2139          * restore prior setting of econtext's caseValue fields, in case this node
2140          * is itself within a larger CASE.
2141          */
2142         save_datum = econtext->caseValue_datum;
2143         save_isNull = econtext->caseValue_isNull;
2144
2145         if (caseExpr->arg)
2146         {
2147                 econtext->caseValue_datum = ExecEvalExpr(caseExpr->arg,
2148                                                                                                  econtext,
2149                                                                                                  &econtext->caseValue_isNull,
2150                                                                                                  NULL);
2151         }
2152
2153         /*
2154          * we evaluate each of the WHEN clauses in turn, as soon as one is true we
2155          * return the corresponding result. If none are true then we return the
2156          * value of the default clause, or NULL if there is none.
2157          */
2158         foreach(clause, clauses)
2159         {
2160                 CaseWhenState *wclause = lfirst(clause);
2161                 Datum           clause_value;
2162
2163                 clause_value = ExecEvalExpr(wclause->expr,
2164                                                                         econtext,
2165                                                                         isNull,
2166                                                                         NULL);
2167
2168                 /*
2169                  * if we have a true test, then we return the result, since the case
2170                  * statement is satisfied.      A NULL result from the test is not
2171                  * considered true.
2172                  */
2173                 if (DatumGetBool(clause_value) && !*isNull)
2174                 {
2175                         econtext->caseValue_datum = save_datum;
2176                         econtext->caseValue_isNull = save_isNull;
2177                         return ExecEvalExpr(wclause->result,
2178                                                                 econtext,
2179                                                                 isNull,
2180                                                                 isDone);
2181                 }
2182         }
2183
2184         econtext->caseValue_datum = save_datum;
2185         econtext->caseValue_isNull = save_isNull;
2186
2187         if (caseExpr->defresult)
2188         {
2189                 return ExecEvalExpr(caseExpr->defresult,
2190                                                         econtext,
2191                                                         isNull,
2192                                                         isDone);
2193         }
2194
2195         *isNull = true;
2196         return (Datum) 0;
2197 }
2198
2199 /*
2200  * ExecEvalCaseTestExpr
2201  *
2202  * Return the value stored by CASE.
2203  */
2204 static Datum
2205 ExecEvalCaseTestExpr(ExprState *exprstate,
2206                                          ExprContext *econtext,
2207                                          bool *isNull, ExprDoneCond *isDone)
2208 {
2209         if (isDone)
2210                 *isDone = ExprSingleResult;
2211         *isNull = econtext->caseValue_isNull;
2212         return econtext->caseValue_datum;
2213 }
2214
2215 /* ----------------------------------------------------------------
2216  *              ExecEvalArray - ARRAY[] expressions
2217  * ----------------------------------------------------------------
2218  */
2219 static Datum
2220 ExecEvalArray(ArrayExprState *astate, ExprContext *econtext,
2221                           bool *isNull, ExprDoneCond *isDone)
2222 {
2223         ArrayExpr  *arrayExpr = (ArrayExpr *) astate->xprstate.expr;
2224         ArrayType  *result;
2225         ListCell   *element;
2226         Oid                     element_type = arrayExpr->element_typeid;
2227         int                     ndims = 0;
2228         int                     dims[MAXDIM];
2229         int                     lbs[MAXDIM];
2230
2231         /* Set default values for result flags: non-null, not a set result */
2232         *isNull = false;
2233         if (isDone)
2234                 *isDone = ExprSingleResult;
2235
2236         if (!arrayExpr->multidims)
2237         {
2238                 /* Elements are presumably of scalar type */
2239                 int                     nelems;
2240                 Datum      *dvalues;
2241                 bool       *dnulls;
2242                 int                     i = 0;
2243
2244                 ndims = 1;
2245                 nelems = list_length(astate->elements);
2246
2247                 /* Shouldn't happen here, but if length is 0, return empty array */
2248                 if (nelems == 0)
2249                         return PointerGetDatum(construct_empty_array(element_type));
2250
2251                 dvalues = (Datum *) palloc(nelems * sizeof(Datum));
2252                 dnulls = (bool *) palloc(nelems * sizeof(bool));
2253
2254                 /* loop through and build array of datums */
2255                 foreach(element, astate->elements)
2256                 {
2257                         ExprState  *e = (ExprState *) lfirst(element);
2258
2259                         dvalues[i] = ExecEvalExpr(e, econtext, &dnulls[i], NULL);
2260                         i++;
2261                 }
2262
2263                 /* setup for 1-D array of the given length */
2264                 dims[0] = nelems;
2265                 lbs[0] = 1;
2266
2267                 result = construct_md_array(dvalues, dnulls, ndims, dims, lbs,
2268                                                                         element_type,
2269                                                                         astate->elemlength,
2270                                                                         astate->elembyval,
2271                                                                         astate->elemalign);
2272         }
2273         else
2274         {
2275                 /* Must be nested array expressions */
2276                 int                     nbytes = 0;
2277                 int                     nitems = 0;
2278                 int                     outer_nelems = 0;
2279                 int                     elem_ndims = 0;
2280                 int                *elem_dims = NULL;
2281                 int                *elem_lbs = NULL;
2282                 bool            firstone = true;
2283                 bool            havenulls = false;
2284                 char      **subdata;
2285                 bits8     **subbitmaps;
2286                 int                *subbytes;
2287                 int                *subnitems;
2288                 int                     i;
2289                 int32           dataoffset;
2290                 char       *dat;
2291                 int                     iitem;
2292
2293                 i = list_length(astate->elements);
2294                 subdata = (char **) palloc(i * sizeof(char *));
2295                 subbitmaps = (bits8 **) palloc(i * sizeof(bits8 *));
2296                 subbytes = (int *) palloc(i * sizeof(int));
2297                 subnitems = (int *) palloc(i * sizeof(int));
2298
2299                 /* loop through and get data area from each element */
2300                 foreach(element, astate->elements)
2301                 {
2302                         ExprState  *e = (ExprState *) lfirst(element);
2303                         bool            eisnull;
2304                         Datum           arraydatum;
2305                         ArrayType  *array;
2306
2307                         arraydatum = ExecEvalExpr(e, econtext, &eisnull, NULL);
2308                         /* ignore null subarrays */
2309                         if (eisnull)
2310                                 continue;
2311
2312                         array = DatumGetArrayTypeP(arraydatum);
2313
2314                         /* run-time double-check on element type */
2315                         if (element_type != ARR_ELEMTYPE(array))
2316                                 ereport(ERROR,
2317                                                 (errcode(ERRCODE_DATATYPE_MISMATCH),
2318                                                  errmsg("cannot merge incompatible arrays"),
2319                                                  errdetail("Array with element type %s cannot be "
2320                                                  "included in ARRAY construct with element type %s.",
2321                                                                    format_type_be(ARR_ELEMTYPE(array)),
2322                                                                    format_type_be(element_type))));
2323
2324                         if (firstone)
2325                         {
2326                                 /* Get sub-array details from first member */
2327                                 elem_ndims = ARR_NDIM(array);
2328                                 ndims = elem_ndims + 1;
2329                                 if (ndims <= 0 || ndims > MAXDIM)
2330                                         ereport(ERROR,
2331                                                         (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
2332                                                   errmsg("number of array dimensions (%d) exceeds " \
2333                                                                  "the maximum allowed (%d)", ndims, MAXDIM)));
2334
2335                                 elem_dims = (int *) palloc(elem_ndims * sizeof(int));
2336                                 memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int));
2337                                 elem_lbs = (int *) palloc(elem_ndims * sizeof(int));
2338                                 memcpy(elem_lbs, ARR_LBOUND(array), elem_ndims * sizeof(int));
2339
2340                                 firstone = false;
2341                         }
2342                         else
2343                         {
2344                                 /* Check other sub-arrays are compatible */
2345                                 if (elem_ndims != ARR_NDIM(array) ||
2346                                         memcmp(elem_dims, ARR_DIMS(array),
2347                                                    elem_ndims * sizeof(int)) != 0 ||
2348                                         memcmp(elem_lbs, ARR_LBOUND(array),
2349                                                    elem_ndims * sizeof(int)) != 0)
2350                                         ereport(ERROR,
2351                                                         (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2352                                                          errmsg("multidimensional arrays must have array "
2353                                                                         "expressions with matching dimensions")));
2354                         }
2355
2356                         subdata[outer_nelems] = ARR_DATA_PTR(array);
2357                         subbitmaps[outer_nelems] = ARR_NULLBITMAP(array);
2358                         subbytes[outer_nelems] = ARR_SIZE(array) - ARR_DATA_OFFSET(array);
2359                         nbytes += subbytes[outer_nelems];
2360                         subnitems[outer_nelems] = ArrayGetNItems(ARR_NDIM(array),
2361                                                                                                          ARR_DIMS(array));
2362                         nitems += subnitems[outer_nelems];
2363                         havenulls |= ARR_HASNULL(array);
2364                         outer_nelems++;
2365                 }
2366
2367                 /* setup for multi-D array */
2368                 dims[0] = outer_nelems;
2369                 lbs[0] = 1;
2370                 for (i = 1; i < ndims; i++)
2371                 {
2372                         dims[i] = elem_dims[i - 1];
2373                         lbs[i] = elem_lbs[i - 1];
2374                 }
2375
2376                 if (havenulls)
2377                 {
2378                         dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
2379                         nbytes += dataoffset;
2380                 }
2381                 else
2382                 {
2383                         dataoffset = 0;         /* marker for no null bitmap */
2384                         nbytes += ARR_OVERHEAD_NONULLS(ndims);
2385                 }
2386
2387                 result = (ArrayType *) palloc(nbytes);
2388                 result->size = nbytes;
2389                 result->ndim = ndims;
2390                 result->dataoffset = dataoffset;
2391                 result->elemtype = element_type;
2392                 memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
2393                 memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
2394
2395                 dat = ARR_DATA_PTR(result);
2396                 iitem = 0;
2397                 for (i = 0; i < outer_nelems; i++)
2398                 {
2399                         memcpy(dat, subdata[i], subbytes[i]);
2400                         dat += subbytes[i];
2401                         if (havenulls)
2402                                 array_bitmap_copy(ARR_NULLBITMAP(result), iitem,
2403                                                                   subbitmaps[i], 0,
2404                                                                   subnitems[i]);
2405                         iitem += subnitems[i];
2406                 }
2407         }
2408
2409         return PointerGetDatum(result);
2410 }
2411
2412 /* ----------------------------------------------------------------
2413  *              ExecEvalRow - ROW() expressions
2414  * ----------------------------------------------------------------
2415  */
2416 static Datum
2417 ExecEvalRow(RowExprState *rstate,
2418                         ExprContext *econtext,
2419                         bool *isNull, ExprDoneCond *isDone)
2420 {
2421         HeapTuple       tuple;
2422         Datum      *values;
2423         bool       *isnull;
2424         int                     natts;
2425         ListCell   *arg;
2426         int                     i;
2427
2428         /* Set default values for result flags: non-null, not a set result */
2429         *isNull = false;
2430         if (isDone)
2431                 *isDone = ExprSingleResult;
2432
2433         /* Allocate workspace */
2434         natts = rstate->tupdesc->natts;
2435         values = (Datum *) palloc0(natts * sizeof(Datum));
2436         isnull = (bool *) palloc(natts * sizeof(bool));
2437
2438         /* preset to nulls in case rowtype has some later-added columns */
2439         memset(isnull, true, natts * sizeof(bool));
2440
2441         /* Evaluate field values */
2442         i = 0;
2443         foreach(arg, rstate->args)
2444         {
2445                 ExprState  *e = (ExprState *) lfirst(arg);
2446
2447                 values[i] = ExecEvalExpr(e, econtext, &isnull[i], NULL);
2448                 i++;
2449         }
2450
2451         tuple = heap_form_tuple(rstate->tupdesc, values, isnull);
2452
2453         pfree(values);
2454         pfree(isnull);
2455
2456         return HeapTupleGetDatum(tuple);
2457 }
2458
2459 /* ----------------------------------------------------------------
2460  *              ExecEvalRowCompare - ROW() comparison-op ROW()
2461  * ----------------------------------------------------------------
2462  */
2463 static Datum
2464 ExecEvalRowCompare(RowCompareExprState *rstate,
2465                                    ExprContext *econtext,
2466                                    bool *isNull, ExprDoneCond *isDone)
2467 {
2468         bool            result;
2469         RowCompareType rctype = ((RowCompareExpr *) rstate->xprstate.expr)->rctype;
2470         int32           cmpresult = 0;
2471         ListCell   *l;
2472         ListCell   *r;
2473         int                     i;
2474
2475         if (isDone)
2476                 *isDone = ExprSingleResult;
2477         *isNull = true;                         /* until we get a result */
2478
2479         i = 0;
2480         forboth(l, rstate->largs, r, rstate->rargs)
2481         {
2482                 ExprState  *le = (ExprState *) lfirst(l);
2483                 ExprState  *re = (ExprState *) lfirst(r);
2484                 FunctionCallInfoData locfcinfo;
2485
2486                 InitFunctionCallInfoData(locfcinfo, &(rstate->funcs[i]), 2,
2487                                                                  NULL, NULL);
2488                 locfcinfo.arg[0] = ExecEvalExpr(le, econtext,
2489                                                                                 &locfcinfo.argnull[0], NULL);
2490                 locfcinfo.arg[1] = ExecEvalExpr(re, econtext,
2491                                                                                 &locfcinfo.argnull[1], NULL);
2492                 if (rstate->funcs[i].fn_strict &&
2493                         (locfcinfo.argnull[0] || locfcinfo.argnull[1]))
2494                         return (Datum) 0;       /* force NULL result */
2495                 locfcinfo.isnull = false;
2496                 cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
2497                 if (locfcinfo.isnull)
2498                         return (Datum) 0;       /* force NULL result */
2499                 if (cmpresult != 0)
2500                         break;                          /* no need to compare remaining columns */
2501                 i++;
2502         }
2503
2504         switch (rctype)
2505         {
2506                 /* EQ and NE cases aren't allowed here */
2507                 case ROWCOMPARE_LT:
2508                         result = (cmpresult < 0);
2509                         break;
2510                 case ROWCOMPARE_LE:
2511                         result = (cmpresult <= 0);
2512                         break;
2513                 case ROWCOMPARE_GE:
2514                         result = (cmpresult >= 0);
2515                         break;
2516                 case ROWCOMPARE_GT:
2517                         result = (cmpresult > 0);
2518                         break;
2519                 default:
2520                         elog(ERROR, "unrecognized RowCompareType: %d", (int) rctype);
2521                         result = 0;                     /* keep compiler quiet */
2522                         break;
2523         }
2524
2525         *isNull = false;
2526         return BoolGetDatum(result);
2527 }
2528
2529 /* ----------------------------------------------------------------
2530  *              ExecEvalCoalesce
2531  * ----------------------------------------------------------------
2532  */
2533 static Datum
2534 ExecEvalCoalesce(CoalesceExprState *coalesceExpr, ExprContext *econtext,
2535                                  bool *isNull, ExprDoneCond *isDone)
2536 {
2537         ListCell   *arg;
2538
2539         if (isDone)
2540                 *isDone = ExprSingleResult;
2541
2542         /* Simply loop through until something NOT NULL is found */
2543         foreach(arg, coalesceExpr->args)
2544         {
2545                 ExprState  *e = (ExprState *) lfirst(arg);
2546                 Datum           value;
2547
2548                 value = ExecEvalExpr(e, econtext, isNull, NULL);
2549                 if (!*isNull)
2550                         return value;
2551         }
2552
2553         /* Else return NULL */
2554         *isNull = true;
2555         return (Datum) 0;
2556 }
2557
2558 /* ----------------------------------------------------------------
2559  *              ExecEvalMinMax
2560  * ----------------------------------------------------------------
2561  */
2562 static Datum
2563 ExecEvalMinMax(MinMaxExprState *minmaxExpr, ExprContext *econtext,
2564                            bool *isNull, ExprDoneCond *isDone)
2565 {
2566         Datum           result = (Datum) 0;
2567         MinMaxOp        op = ((MinMaxExpr *) minmaxExpr->xprstate.expr)->op;
2568         FunctionCallInfoData locfcinfo;
2569         ListCell   *arg;
2570
2571         if (isDone)
2572                 *isDone = ExprSingleResult;
2573         *isNull = true;                         /* until we get a result */
2574
2575         InitFunctionCallInfoData(locfcinfo, &minmaxExpr->cfunc, 2, NULL, NULL);
2576         locfcinfo.argnull[0] = false;
2577         locfcinfo.argnull[1] = false;
2578
2579         foreach(arg, minmaxExpr->args)
2580         {
2581                 ExprState  *e = (ExprState *) lfirst(arg);
2582                 Datum           value;
2583                 bool            valueIsNull;
2584                 int32           cmpresult;
2585
2586                 value = ExecEvalExpr(e, econtext, &valueIsNull, NULL);
2587                 if (valueIsNull)
2588                         continue;                       /* ignore NULL inputs */
2589
2590                 if (*isNull)
2591                 {
2592                         /* first nonnull input, adopt value */
2593                         result = value;
2594                         *isNull = false;
2595                 }
2596                 else
2597                 {
2598                         /* apply comparison function */
2599                         locfcinfo.arg[0] = result;
2600                         locfcinfo.arg[1] = value;
2601                         locfcinfo.isnull = false;
2602                         cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
2603                         if (locfcinfo.isnull)           /* probably should not happen */
2604                                 continue;
2605                         if (cmpresult > 0 && op == IS_LEAST)
2606                                 result = value;
2607                         else if (cmpresult < 0 && op == IS_GREATEST)
2608                                 result = value;
2609                 }
2610         }
2611
2612         return result;
2613 }
2614
2615 /* ----------------------------------------------------------------
2616  *              ExecEvalNullIf
2617  *
2618  * Note that this is *always* derived from the equals operator,
2619  * but since we need special processing of the arguments
2620  * we can not simply reuse ExecEvalOper() or ExecEvalFunc().
2621  * ----------------------------------------------------------------
2622  */
2623 static Datum
2624 ExecEvalNullIf(FuncExprState *nullIfExpr,
2625                            ExprContext *econtext,
2626                            bool *isNull, ExprDoneCond *isDone)
2627 {
2628         Datum           result;
2629         FunctionCallInfoData fcinfo;
2630         ExprDoneCond argDone;
2631         List       *argList;
2632
2633         if (isDone)
2634                 *isDone = ExprSingleResult;
2635
2636         /*
2637          * Initialize function cache if first time through
2638          */
2639         if (nullIfExpr->func.fn_oid == InvalidOid)
2640         {
2641                 NullIfExpr *op = (NullIfExpr *) nullIfExpr->xprstate.expr;
2642
2643                 init_fcache(op->opfuncid, nullIfExpr, econtext->ecxt_per_query_memory);
2644                 Assert(!nullIfExpr->func.fn_retset);
2645         }
2646
2647         /*
2648          * extract info from nullIfExpr
2649          */
2650         argList = nullIfExpr->args;
2651
2652         /* Need to prep callinfo structure */
2653         InitFunctionCallInfoData(fcinfo, &(nullIfExpr->func), 0, NULL, NULL);
2654         argDone = ExecEvalFuncArgs(&fcinfo, argList, econtext);
2655         if (argDone != ExprSingleResult)
2656                 ereport(ERROR,
2657                                 (errcode(ERRCODE_DATATYPE_MISMATCH),
2658                                  errmsg("NULLIF does not support set arguments")));
2659         Assert(fcinfo.nargs == 2);
2660
2661         /* if either argument is NULL they can't be equal */
2662         if (!fcinfo.argnull[0] && !fcinfo.argnull[1])
2663         {
2664                 fcinfo.isnull = false;
2665                 result = FunctionCallInvoke(&fcinfo);
2666                 /* if the arguments are equal return null */
2667                 if (!fcinfo.isnull && DatumGetBool(result))
2668                 {
2669                         *isNull = true;
2670                         return (Datum) 0;
2671                 }
2672         }
2673
2674         /* else return first argument */
2675         *isNull = fcinfo.argnull[0];
2676         return fcinfo.arg[0];
2677 }
2678
2679 /* ----------------------------------------------------------------
2680  *              ExecEvalNullTest
2681  *
2682  *              Evaluate a NullTest node.
2683  * ----------------------------------------------------------------
2684  */
2685 static Datum
2686 ExecEvalNullTest(GenericExprState *nstate,
2687                                  ExprContext *econtext,
2688                                  bool *isNull,
2689                                  ExprDoneCond *isDone)
2690 {
2691         NullTest   *ntest = (NullTest *) nstate->xprstate.expr;
2692         Datum           result;
2693
2694         result = ExecEvalExpr(nstate->arg, econtext, isNull, isDone);
2695
2696         if (isDone && *isDone == ExprEndResult)
2697                 return result;                  /* nothing to check */
2698
2699         switch (ntest->nulltesttype)
2700         {
2701                 case IS_NULL:
2702                         if (*isNull)
2703                         {
2704                                 *isNull = false;
2705                                 return BoolGetDatum(true);
2706                         }
2707                         else
2708                                 return BoolGetDatum(false);
2709                 case IS_NOT_NULL:
2710                         if (*isNull)
2711                         {
2712                                 *isNull = false;
2713                                 return BoolGetDatum(false);
2714                         }
2715                         else
2716                                 return BoolGetDatum(true);
2717                 default:
2718                         elog(ERROR, "unrecognized nulltesttype: %d",
2719                                  (int) ntest->nulltesttype);
2720                         return (Datum) 0;       /* keep compiler quiet */
2721         }
2722 }
2723
2724 /* ----------------------------------------------------------------
2725  *              ExecEvalBooleanTest
2726  *
2727  *              Evaluate a BooleanTest node.
2728  * ----------------------------------------------------------------
2729  */
2730 static Datum
2731 ExecEvalBooleanTest(GenericExprState *bstate,
2732                                         ExprContext *econtext,
2733                                         bool *isNull,
2734                                         ExprDoneCond *isDone)
2735 {
2736         BooleanTest *btest = (BooleanTest *) bstate->xprstate.expr;
2737         Datum           result;
2738
2739         result = ExecEvalExpr(bstate->arg, econtext, isNull, isDone);
2740
2741         if (isDone && *isDone == ExprEndResult)
2742                 return result;                  /* nothing to check */
2743
2744         switch (btest->booltesttype)
2745         {
2746                 case IS_TRUE:
2747                         if (*isNull)
2748                         {
2749                                 *isNull = false;
2750                                 return BoolGetDatum(false);
2751                         }
2752                         else if (DatumGetBool(result))
2753                                 return BoolGetDatum(true);
2754                         else
2755                                 return BoolGetDatum(false);
2756                 case IS_NOT_TRUE:
2757                         if (*isNull)
2758                         {
2759                                 *isNull = false;
2760                                 return BoolGetDatum(true);
2761                         }
2762                         else if (DatumGetBool(result))
2763                                 return BoolGetDatum(false);
2764                         else
2765                                 return BoolGetDatum(true);
2766                 case IS_FALSE:
2767                         if (*isNull)
2768                         {
2769                                 *isNull = false;
2770                                 return BoolGetDatum(false);
2771                         }
2772                         else if (DatumGetBool(result))
2773                                 return BoolGetDatum(false);
2774                         else
2775                                 return BoolGetDatum(true);
2776                 case IS_NOT_FALSE:
2777                         if (*isNull)
2778                         {
2779                                 *isNull = false;
2780                                 return BoolGetDatum(true);
2781                         }
2782                         else if (DatumGetBool(result))
2783                                 return BoolGetDatum(true);
2784                         else
2785                                 return BoolGetDatum(false);
2786                 case IS_UNKNOWN:
2787                         if (*isNull)
2788                         {
2789                                 *isNull = false;
2790                                 return BoolGetDatum(true);
2791                         }
2792                         else
2793                                 return BoolGetDatum(false);
2794                 case IS_NOT_UNKNOWN:
2795                         if (*isNull)
2796                         {
2797                                 *isNull = false;
2798                                 return BoolGetDatum(false);
2799                         }
2800                         else
2801                                 return BoolGetDatum(true);
2802                 default:
2803                         elog(ERROR, "unrecognized booltesttype: %d",
2804                                  (int) btest->booltesttype);
2805                         return (Datum) 0;       /* keep compiler quiet */
2806         }
2807 }
2808
2809 /*
2810  * ExecEvalCoerceToDomain
2811  *
2812  * Test the provided data against the domain constraint(s).  If the data
2813  * passes the constraint specifications, pass it through (return the
2814  * datum) otherwise throw an error.
2815  */
2816 static Datum
2817 ExecEvalCoerceToDomain(CoerceToDomainState *cstate, ExprContext *econtext,
2818                                            bool *isNull, ExprDoneCond *isDone)
2819 {
2820         CoerceToDomain *ctest = (CoerceToDomain *) cstate->xprstate.expr;
2821         Datum           result;
2822         ListCell   *l;
2823
2824         result = ExecEvalExpr(cstate->arg, econtext, isNull, isDone);
2825
2826         if (isDone && *isDone == ExprEndResult)
2827                 return result;                  /* nothing to check */
2828
2829         foreach(l, cstate->constraints)
2830         {
2831                 DomainConstraintState *con = (DomainConstraintState *) lfirst(l);
2832
2833                 switch (con->constrainttype)
2834                 {
2835                         case DOM_CONSTRAINT_NOTNULL:
2836                                 if (*isNull)
2837                                         ereport(ERROR,
2838                                                         (errcode(ERRCODE_NOT_NULL_VIOLATION),
2839                                                          errmsg("domain %s does not allow null values",
2840                                                                         format_type_be(ctest->resulttype))));
2841                                 break;
2842                         case DOM_CONSTRAINT_CHECK:
2843                                 {
2844                                         Datum           conResult;
2845                                         bool            conIsNull;
2846                                         Datum           save_datum;
2847                                         bool            save_isNull;
2848
2849                                         /*
2850                                          * Set up value to be returned by CoerceToDomainValue
2851                                          * nodes. We must save and restore prior setting of
2852                                          * econtext's domainValue fields, in case this node is
2853                                          * itself within a check expression for another domain.
2854                                          */
2855                                         save_datum = econtext->domainValue_datum;
2856                                         save_isNull = econtext->domainValue_isNull;
2857
2858                                         econtext->domainValue_datum = result;
2859                                         econtext->domainValue_isNull = *isNull;
2860
2861                                         conResult = ExecEvalExpr(con->check_expr,
2862                                                                                          econtext, &conIsNull, NULL);
2863
2864                                         if (!conIsNull &&
2865                                                 !DatumGetBool(conResult))
2866                                                 ereport(ERROR,
2867                                                                 (errcode(ERRCODE_CHECK_VIOLATION),
2868                                                                  errmsg("value for domain %s violates check constraint \"%s\"",
2869                                                                                 format_type_be(ctest->resulttype),
2870                                                                                 con->name)));
2871                                         econtext->domainValue_datum = save_datum;
2872                                         econtext->domainValue_isNull = save_isNull;
2873
2874                                         break;
2875                                 }
2876                         default:
2877                                 elog(ERROR, "unrecognized constraint type: %d",
2878                                          (int) con->constrainttype);
2879                                 break;
2880                 }
2881         }
2882
2883         /* If all has gone well (constraints did not fail) return the datum */
2884         return result;
2885 }
2886
2887 /*
2888  * ExecEvalCoerceToDomainValue
2889  *
2890  * Return the value stored by CoerceToDomain.
2891  */
2892 static Datum
2893 ExecEvalCoerceToDomainValue(ExprState *exprstate,
2894                                                         ExprContext *econtext,
2895                                                         bool *isNull, ExprDoneCond *isDone)
2896 {
2897         if (isDone)
2898                 *isDone = ExprSingleResult;
2899         *isNull = econtext->domainValue_isNull;
2900         return econtext->domainValue_datum;
2901 }
2902
2903 /* ----------------------------------------------------------------
2904  *              ExecEvalFieldSelect
2905  *
2906  *              Evaluate a FieldSelect node.
2907  * ----------------------------------------------------------------
2908  */
2909 static Datum
2910 ExecEvalFieldSelect(FieldSelectState *fstate,
2911                                         ExprContext *econtext,
2912                                         bool *isNull,
2913                                         ExprDoneCond *isDone)
2914 {
2915         FieldSelect *fselect = (FieldSelect *) fstate->xprstate.expr;
2916         Datum           result;
2917         Datum           tupDatum;
2918         HeapTupleHeader tuple;
2919         Oid                     tupType;
2920         int32           tupTypmod;
2921         TupleDesc       tupDesc;
2922         HeapTupleData tmptup;
2923
2924         tupDatum = ExecEvalExpr(fstate->arg, econtext, isNull, isDone);
2925
2926         /* this test covers the isDone exception too: */
2927         if (*isNull)
2928                 return tupDatum;
2929
2930         tuple = DatumGetHeapTupleHeader(tupDatum);
2931
2932         tupType = HeapTupleHeaderGetTypeId(tuple);
2933         tupTypmod = HeapTupleHeaderGetTypMod(tuple);
2934
2935         /* Lookup tupdesc if first time through or if type changes */
2936         tupDesc = get_cached_rowtype(tupType, tupTypmod,
2937                                                                  &fstate->argdesc, econtext);
2938
2939         /*
2940          * heap_getattr needs a HeapTuple not a bare HeapTupleHeader.  We set all
2941          * the fields in the struct just in case user tries to inspect system
2942          * columns.
2943          */
2944         tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
2945         ItemPointerSetInvalid(&(tmptup.t_self));
2946         tmptup.t_tableOid = InvalidOid;
2947         tmptup.t_data = tuple;
2948
2949         result = heap_getattr(&tmptup,
2950                                                   fselect->fieldnum,
2951                                                   tupDesc,
2952                                                   isNull);
2953         return result;
2954 }
2955
2956 /* ----------------------------------------------------------------
2957  *              ExecEvalFieldStore
2958  *
2959  *              Evaluate a FieldStore node.
2960  * ----------------------------------------------------------------
2961  */
2962 static Datum
2963 ExecEvalFieldStore(FieldStoreState *fstate,
2964                                    ExprContext *econtext,
2965                                    bool *isNull,
2966                                    ExprDoneCond *isDone)
2967 {
2968         FieldStore *fstore = (FieldStore *) fstate->xprstate.expr;
2969         HeapTuple       tuple;
2970         Datum           tupDatum;
2971         TupleDesc       tupDesc;
2972         Datum      *values;
2973         bool       *isnull;
2974         Datum           save_datum;
2975         bool            save_isNull;
2976         ListCell   *l1,
2977                            *l2;
2978
2979         tupDatum = ExecEvalExpr(fstate->arg, econtext, isNull, isDone);
2980
2981         if (isDone && *isDone == ExprEndResult)
2982                 return tupDatum;
2983
2984         /* Lookup tupdesc if first time through or after rescan */
2985         tupDesc = get_cached_rowtype(fstore->resulttype, -1,
2986                                                                  &fstate->argdesc, econtext);
2987
2988         /* Allocate workspace */
2989         values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
2990         isnull = (bool *) palloc(tupDesc->natts * sizeof(bool));
2991
2992         if (!*isNull)
2993         {
2994                 /*
2995                  * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader. We
2996                  * set all the fields in the struct just in case.
2997                  */
2998                 HeapTupleHeader tuphdr;
2999                 HeapTupleData tmptup;
3000
3001                 tuphdr = DatumGetHeapTupleHeader(tupDatum);
3002                 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
3003                 ItemPointerSetInvalid(&(tmptup.t_self));
3004                 tmptup.t_tableOid = InvalidOid;
3005                 tmptup.t_data = tuphdr;
3006
3007                 heap_deform_tuple(&tmptup, tupDesc, values, isnull);
3008         }
3009         else
3010         {
3011                 /* Convert null input tuple into an all-nulls row */
3012                 memset(isnull, true, tupDesc->natts * sizeof(bool));
3013         }
3014
3015         /* Result is never null */
3016         *isNull = false;
3017
3018         save_datum = econtext->caseValue_datum;
3019         save_isNull = econtext->caseValue_isNull;
3020
3021         forboth(l1, fstate->newvals, l2, fstore->fieldnums)
3022         {
3023                 ExprState  *newval = (ExprState *) lfirst(l1);
3024                 AttrNumber      fieldnum = lfirst_int(l2);
3025
3026                 Assert(fieldnum > 0 && fieldnum <= tupDesc->natts);
3027
3028                 /*
3029                  * Use the CaseTestExpr mechanism to pass down the old value of the
3030                  * field being replaced; this is useful in case we have a nested field
3031                  * update situation.  It's safe to reuse the CASE mechanism because
3032                  * there cannot be a CASE between here and where the value would be
3033                  * needed.
3034                  */
3035                 econtext->caseValue_datum = values[fieldnum - 1];
3036                 econtext->caseValue_isNull = isnull[fieldnum - 1];
3037
3038                 values[fieldnum - 1] = ExecEvalExpr(newval,
3039                                                                                         econtext,
3040                                                                                         &isnull[fieldnum - 1],
3041                                                                                         NULL);
3042         }
3043
3044         econtext->caseValue_datum = save_datum;
3045         econtext->caseValue_isNull = save_isNull;
3046
3047         tuple = heap_form_tuple(tupDesc, values, isnull);
3048
3049         pfree(values);
3050         pfree(isnull);
3051
3052         return HeapTupleGetDatum(tuple);
3053 }
3054
3055 /* ----------------------------------------------------------------
3056  *              ExecEvalRelabelType
3057  *
3058  *              Evaluate a RelabelType node.
3059  * ----------------------------------------------------------------
3060  */
3061 static Datum
3062 ExecEvalRelabelType(GenericExprState *exprstate,
3063                                         ExprContext *econtext,
3064                                         bool *isNull, ExprDoneCond *isDone)
3065 {
3066         return ExecEvalExpr(exprstate->arg, econtext, isNull, isDone);
3067 }
3068
3069
3070 /*
3071  * ExecEvalExprSwitchContext
3072  *
3073  * Same as ExecEvalExpr, but get into the right allocation context explicitly.
3074  */
3075 Datum
3076 ExecEvalExprSwitchContext(ExprState *expression,
3077                                                   ExprContext *econtext,
3078                                                   bool *isNull,
3079                                                   ExprDoneCond *isDone)
3080 {
3081         Datum           retDatum;
3082         MemoryContext oldContext;
3083
3084         oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
3085         retDatum = ExecEvalExpr(expression, econtext, isNull, isDone);
3086         MemoryContextSwitchTo(oldContext);
3087         return retDatum;
3088 }
3089
3090
3091 /*
3092  * ExecInitExpr: prepare an expression tree for execution
3093  *
3094  * This function builds and returns an ExprState tree paralleling the given
3095  * Expr node tree.      The ExprState tree can then be handed to ExecEvalExpr
3096  * for execution.  Because the Expr tree itself is read-only as far as
3097  * ExecInitExpr and ExecEvalExpr are concerned, several different executions
3098  * of the same plan tree can occur concurrently.
3099  *
3100  * This must be called in a memory context that will last as long as repeated
3101  * executions of the expression are needed.  Typically the context will be
3102  * the same as the per-query context of the associated ExprContext.
3103  *
3104  * Any Aggref and SubPlan nodes found in the tree are added to the lists
3105  * of such nodes held by the parent PlanState.  Otherwise, we do very little
3106  * initialization here other than building the state-node tree.  Any nontrivial
3107  * work associated with initializing runtime info for a node should happen
3108  * during the first actual evaluation of that node.  (This policy lets us
3109  * avoid work if the node is never actually evaluated.)
3110  *
3111  * Note: there is no ExecEndExpr function; we assume that any resource
3112  * cleanup needed will be handled by just releasing the memory context
3113  * in which the state tree is built.  Functions that require additional
3114  * cleanup work can register a shutdown callback in the ExprContext.
3115  *
3116  *      'node' is the root of the expression tree to examine
3117  *      'parent' is the PlanState node that owns the expression.
3118  *
3119  * 'parent' may be NULL if we are preparing an expression that is not
3120  * associated with a plan tree.  (If so, it can't have aggs or subplans.)
3121  * This case should usually come through ExecPrepareExpr, not directly here.
3122  */
3123 ExprState *
3124 ExecInitExpr(Expr *node, PlanState *parent)
3125 {
3126         ExprState  *state;
3127
3128         if (node == NULL)
3129                 return NULL;
3130
3131         /* Guard against stack overflow due to overly complex expressions */
3132         check_stack_depth();
3133
3134         switch (nodeTag(node))
3135         {
3136                 case T_Var:
3137                         {
3138                                 Var                *var = (Var *) node;
3139
3140                                 state = (ExprState *) makeNode(ExprState);
3141                                 if (var->varattno != InvalidAttrNumber)
3142                                         state->evalfunc = ExecEvalVar;
3143                                 else
3144                                         state->evalfunc = ExecEvalWholeRowVar;
3145                         }
3146                         break;
3147                 case T_Const:
3148                         state = (ExprState *) makeNode(ExprState);
3149                         state->evalfunc = ExecEvalConst;
3150                         break;
3151                 case T_Param:
3152                         state = (ExprState *) makeNode(ExprState);
3153                         state->evalfunc = ExecEvalParam;
3154                         break;
3155                 case T_CoerceToDomainValue:
3156                         state = (ExprState *) makeNode(ExprState);
3157                         state->evalfunc = ExecEvalCoerceToDomainValue;
3158                         break;
3159                 case T_CaseTestExpr:
3160                         state = (ExprState *) makeNode(ExprState);
3161                         state->evalfunc = ExecEvalCaseTestExpr;
3162                         break;
3163                 case T_Aggref:
3164                         {
3165                                 Aggref     *aggref = (Aggref *) node;
3166                                 AggrefExprState *astate = makeNode(AggrefExprState);
3167
3168                                 astate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalAggref;
3169                                 if (parent && IsA(parent, AggState))
3170                                 {
3171                                         AggState   *aggstate = (AggState *) parent;
3172                                         int                     naggs;
3173
3174                                         aggstate->aggs = lcons(astate, aggstate->aggs);
3175                                         naggs = ++aggstate->numaggs;
3176
3177                                         astate->target = ExecInitExpr(aggref->target, parent);
3178
3179                                         /*
3180                                          * Complain if the aggregate's argument contains any
3181                                          * aggregates; nested agg functions are semantically
3182                                          * nonsensical.  (This should have been caught earlier,
3183                                          * but we defend against it here anyway.)
3184                                          */
3185                                         if (naggs != aggstate->numaggs)
3186                                                 ereport(ERROR,
3187                                                                 (errcode(ERRCODE_GROUPING_ERROR),
3188                                                                  errmsg("aggregate function calls may not be nested")));
3189                                 }
3190                                 else
3191                                 {
3192                                         /* planner messed up */
3193                                         elog(ERROR, "aggref found in non-Agg plan node");
3194                                 }
3195                                 state = (ExprState *) astate;
3196                         }
3197                         break;
3198                 case T_ArrayRef:
3199                         {
3200                                 ArrayRef   *aref = (ArrayRef *) node;
3201                                 ArrayRefExprState *astate = makeNode(ArrayRefExprState);
3202
3203                                 astate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalArrayRef;
3204                                 astate->refupperindexpr = (List *)
3205                                         ExecInitExpr((Expr *) aref->refupperindexpr, parent);
3206                                 astate->reflowerindexpr = (List *)
3207                                         ExecInitExpr((Expr *) aref->reflowerindexpr, parent);
3208                                 astate->refexpr = ExecInitExpr(aref->refexpr, parent);
3209                                 astate->refassgnexpr = ExecInitExpr(aref->refassgnexpr,
3210                                                                                                         parent);
3211                                 /* do one-time catalog lookups for type info */
3212                                 astate->refattrlength = get_typlen(aref->refarraytype);
3213                                 get_typlenbyvalalign(aref->refelemtype,
3214                                                                          &astate->refelemlength,
3215                                                                          &astate->refelembyval,
3216                                                                          &astate->refelemalign);
3217                                 state = (ExprState *) astate;
3218                         }
3219                         break;
3220                 case T_FuncExpr:
3221                         {
3222                                 FuncExpr   *funcexpr = (FuncExpr *) node;
3223                                 FuncExprState *fstate = makeNode(FuncExprState);
3224
3225                                 fstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalFunc;
3226                                 fstate->args = (List *)
3227                                         ExecInitExpr((Expr *) funcexpr->args, parent);
3228                                 fstate->func.fn_oid = InvalidOid;               /* not initialized */
3229                                 state = (ExprState *) fstate;
3230                         }
3231                         break;
3232                 case T_OpExpr:
3233                         {
3234                                 OpExpr     *opexpr = (OpExpr *) node;
3235                                 FuncExprState *fstate = makeNode(FuncExprState);
3236
3237                                 fstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalOper;
3238                                 fstate->args = (List *)
3239                                         ExecInitExpr((Expr *) opexpr->args, parent);
3240                                 fstate->func.fn_oid = InvalidOid;               /* not initialized */
3241                                 state = (ExprState *) fstate;
3242                         }
3243                         break;
3244                 case T_DistinctExpr:
3245                         {
3246                                 DistinctExpr *distinctexpr = (DistinctExpr *) node;
3247                                 FuncExprState *fstate = makeNode(FuncExprState);
3248
3249                                 fstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalDistinct;
3250                                 fstate->args = (List *)
3251                                         ExecInitExpr((Expr *) distinctexpr->args, parent);
3252                                 fstate->func.fn_oid = InvalidOid;               /* not initialized */
3253                                 state = (ExprState *) fstate;
3254                         }
3255                         break;
3256                 case T_ScalarArrayOpExpr:
3257                         {
3258                                 ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
3259                                 ScalarArrayOpExprState *sstate = makeNode(ScalarArrayOpExprState);
3260
3261                                 sstate->fxprstate.xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalScalarArrayOp;
3262                                 sstate->fxprstate.args = (List *)
3263                                         ExecInitExpr((Expr *) opexpr->args, parent);
3264                                 sstate->fxprstate.func.fn_oid = InvalidOid;             /* not initialized */
3265                                 sstate->element_type = InvalidOid;              /* ditto */
3266                                 state = (ExprState *) sstate;
3267                         }
3268                         break;
3269                 case T_BoolExpr:
3270                         {
3271                                 BoolExpr   *boolexpr = (BoolExpr *) node;
3272                                 BoolExprState *bstate = makeNode(BoolExprState);
3273
3274                                 switch (boolexpr->boolop)
3275                                 {
3276                                         case AND_EXPR:
3277                                                 bstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalAnd;
3278                                                 break;
3279                                         case OR_EXPR:
3280                                                 bstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalOr;
3281                                                 break;
3282                                         case NOT_EXPR:
3283                                                 bstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalNot;
3284                                                 break;
3285                                         default:
3286                                                 elog(ERROR, "unrecognized boolop: %d",
3287                                                          (int) boolexpr->boolop);
3288                                                 break;
3289                                 }
3290                                 bstate->args = (List *)
3291                                         ExecInitExpr((Expr *) boolexpr->args, parent);
3292                                 state = (ExprState *) bstate;
3293                         }
3294                         break;
3295                 case T_SubPlan:
3296                         {
3297                                 /* Keep this in sync with ExecInitExprInitPlan, below */
3298                                 SubPlan    *subplan = (SubPlan *) node;
3299                                 SubPlanState *sstate = makeNode(SubPlanState);
3300
3301                                 sstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecSubPlan;
3302
3303                                 if (!parent)
3304                                         elog(ERROR, "SubPlan found with no parent plan");
3305
3306                                 /*
3307                                  * Here we just add the SubPlanState nodes to parent->subPlan.
3308                                  * The subplans will be initialized later.
3309                                  */
3310                                 parent->subPlan = lcons(sstate, parent->subPlan);
3311                                 sstate->sub_estate = NULL;
3312                                 sstate->planstate = NULL;
3313
3314                                 sstate->testexpr =
3315                                         ExecInitExpr((Expr *) subplan->testexpr, parent);
3316                                 sstate->args = (List *)
3317                                         ExecInitExpr((Expr *) subplan->args, parent);
3318
3319                                 state = (ExprState *) sstate;
3320                         }
3321                         break;
3322                 case T_FieldSelect:
3323                         {
3324                                 FieldSelect *fselect = (FieldSelect *) node;
3325                                 FieldSelectState *fstate = makeNode(FieldSelectState);
3326
3327                                 fstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalFieldSelect;
3328                                 fstate->arg = ExecInitExpr(fselect->arg, parent);
3329                                 fstate->argdesc = NULL;
3330                                 state = (ExprState *) fstate;
3331                         }
3332                         break;
3333                 case T_FieldStore:
3334                         {
3335                                 FieldStore *fstore = (FieldStore *) node;
3336                                 FieldStoreState *fstate = makeNode(FieldStoreState);
3337
3338                                 fstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalFieldStore;
3339                                 fstate->arg = ExecInitExpr(fstore->arg, parent);
3340                                 fstate->newvals = (List *) ExecInitExpr((Expr *) fstore->newvals, parent);
3341                                 fstate->argdesc = NULL;
3342                                 state = (ExprState *) fstate;
3343                         }
3344                         break;
3345                 case T_RelabelType:
3346                         {
3347                                 RelabelType *relabel = (RelabelType *) node;
3348                                 GenericExprState *gstate = makeNode(GenericExprState);
3349
3350                                 gstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalRelabelType;
3351                                 gstate->arg = ExecInitExpr(relabel->arg, parent);
3352                                 state = (ExprState *) gstate;
3353                         }
3354                         break;
3355                 case T_ConvertRowtypeExpr:
3356                         {
3357                                 ConvertRowtypeExpr *convert = (ConvertRowtypeExpr *) node;
3358                                 ConvertRowtypeExprState *cstate = makeNode(ConvertRowtypeExprState);
3359
3360                                 cstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalConvertRowtype;
3361                                 cstate->arg = ExecInitExpr(convert->arg, parent);
3362                                 state = (ExprState *) cstate;
3363                         }
3364                         break;
3365                 case T_CaseExpr:
3366                         {
3367                                 CaseExpr   *caseexpr = (CaseExpr *) node;
3368                                 CaseExprState *cstate = makeNode(CaseExprState);
3369                                 List       *outlist = NIL;
3370                                 ListCell   *l;
3371
3372                                 cstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalCase;
3373                                 cstate->arg = ExecInitExpr(caseexpr->arg, parent);
3374                                 foreach(l, caseexpr->args)
3375                                 {
3376                                         CaseWhen   *when = (CaseWhen *) lfirst(l);
3377                                         CaseWhenState *wstate = makeNode(CaseWhenState);
3378
3379                                         Assert(IsA(when, CaseWhen));
3380                                         wstate->xprstate.evalfunc = NULL;       /* not used */
3381                                         wstate->xprstate.expr = (Expr *) when;
3382                                         wstate->expr = ExecInitExpr(when->expr, parent);
3383                                         wstate->result = ExecInitExpr(when->result, parent);
3384                                         outlist = lappend(outlist, wstate);
3385                                 }
3386                                 cstate->args = outlist;
3387                                 cstate->defresult = ExecInitExpr(caseexpr->defresult, parent);
3388                                 state = (ExprState *) cstate;
3389                         }
3390                         break;
3391                 case T_ArrayExpr:
3392                         {
3393                                 ArrayExpr  *arrayexpr = (ArrayExpr *) node;
3394                                 ArrayExprState *astate = makeNode(ArrayExprState);
3395                                 List       *outlist = NIL;
3396                                 ListCell   *l;
3397
3398                                 astate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalArray;
3399                                 foreach(l, arrayexpr->elements)
3400                                 {
3401                                         Expr       *e = (Expr *) lfirst(l);
3402                                         ExprState  *estate;
3403
3404                                         estate = ExecInitExpr(e, parent);
3405                                         outlist = lappend(outlist, estate);
3406                                 }
3407                                 astate->elements = outlist;
3408                                 /* do one-time catalog lookup for type info */
3409                                 get_typlenbyvalalign(arrayexpr->element_typeid,
3410                                                                          &astate->elemlength,
3411                                                                          &astate->elembyval,
3412                                                                          &astate->elemalign);
3413                                 state = (ExprState *) astate;
3414                         }
3415                         break;
3416                 case T_RowExpr:
3417                         {
3418                                 RowExpr    *rowexpr = (RowExpr *) node;
3419                                 RowExprState *rstate = makeNode(RowExprState);
3420                                 Form_pg_attribute *attrs;
3421                                 List       *outlist = NIL;
3422                                 ListCell   *l;
3423                                 int                     i;
3424
3425                                 rstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalRow;
3426                                 /* Build tupdesc to describe result tuples */
3427                                 if (rowexpr->row_typeid == RECORDOID)
3428                                 {
3429                                         /* generic record, use runtime type assignment */
3430                                         rstate->tupdesc = ExecTypeFromExprList(rowexpr->args);
3431                                         BlessTupleDesc(rstate->tupdesc);
3432                                         /* we won't need to redo this at runtime */
3433                                 }
3434                                 else
3435                                 {
3436                                         /* it's been cast to a named type, use that */
3437                                         rstate->tupdesc = lookup_rowtype_tupdesc_copy(rowexpr->row_typeid, -1);
3438                                 }
3439                                 /* Set up evaluation, skipping any deleted columns */
3440                                 Assert(list_length(rowexpr->args) <= rstate->tupdesc->natts);
3441                                 attrs = rstate->tupdesc->attrs;
3442                                 i = 0;
3443                                 foreach(l, rowexpr->args)
3444                                 {
3445                                         Expr       *e = (Expr *) lfirst(l);
3446                                         ExprState  *estate;
3447
3448                                         if (!attrs[i]->attisdropped)
3449                                         {
3450                                                 /*
3451                                                  * Guard against ALTER COLUMN TYPE on rowtype since
3452                                                  * the RowExpr was created.  XXX should we check
3453                                                  * typmod too?  Not sure we can be sure it'll be the
3454                                                  * same.
3455                                                  */
3456                                                 if (exprType((Node *) e) != attrs[i]->atttypid)
3457                                                         ereport(ERROR,
3458                                                                         (errcode(ERRCODE_DATATYPE_MISMATCH),
3459                                                                          errmsg("ROW() column has type %s instead of type %s",
3460                                                                                 format_type_be(exprType((Node *) e)),
3461                                                                            format_type_be(attrs[i]->atttypid))));
3462                                         }
3463                                         else
3464                                         {
3465                                                 /*
3466                                                  * Ignore original expression and insert a NULL. We
3467                                                  * don't really care what type of NULL it is, so
3468                                                  * always make an int4 NULL.
3469                                                  */
3470                                                 e = (Expr *) makeNullConst(INT4OID);
3471                                         }
3472                                         estate = ExecInitExpr(e, parent);
3473                                         outlist = lappend(outlist, estate);
3474                                         i++;
3475                                 }
3476                                 rstate->args = outlist;
3477                                 state = (ExprState *) rstate;
3478                         }
3479                         break;
3480                 case T_RowCompareExpr:
3481                         {
3482                                 RowCompareExpr *rcexpr = (RowCompareExpr *) node;
3483                                 RowCompareExprState *rstate = makeNode(RowCompareExprState);
3484                                 int                     nopers = list_length(rcexpr->opnos);
3485                                 List       *outlist;
3486                                 ListCell   *l;
3487                                 ListCell   *l2;
3488                                 int                     i;
3489
3490                                 rstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalRowCompare;
3491                                 Assert(list_length(rcexpr->largs) == nopers);
3492                                 outlist = NIL;
3493                                 foreach(l, rcexpr->largs)
3494                                 {
3495                                         Expr       *e = (Expr *) lfirst(l);
3496                                         ExprState  *estate;
3497
3498                                         estate = ExecInitExpr(e, parent);
3499                                         outlist = lappend(outlist, estate);
3500                                 }
3501                                 rstate->largs = outlist;
3502                                 Assert(list_length(rcexpr->rargs) == nopers);
3503                                 outlist = NIL;
3504                                 foreach(l, rcexpr->rargs)
3505                                 {
3506                                         Expr       *e = (Expr *) lfirst(l);
3507                                         ExprState  *estate;
3508
3509                                         estate = ExecInitExpr(e, parent);
3510                                         outlist = lappend(outlist, estate);
3511                                 }
3512                                 rstate->rargs = outlist;
3513                                 Assert(list_length(rcexpr->opclasses) == nopers);
3514                                 rstate->funcs = (FmgrInfo *) palloc(nopers * sizeof(FmgrInfo));
3515                                 i = 0;
3516                                 forboth(l, rcexpr->opnos, l2, rcexpr->opclasses)
3517                                 {
3518                                         Oid             opno = lfirst_oid(l);
3519                                         Oid             opclass = lfirst_oid(l2);
3520                                         int             strategy;
3521                                         Oid             subtype;
3522                                         bool    recheck;
3523                                         Oid             proc;
3524
3525                                         get_op_opclass_properties(opno, opclass,
3526                                                                                           &strategy, &subtype, &recheck);
3527                                         proc = get_opclass_proc(opclass, subtype, BTORDER_PROC);
3528                                         /*
3529                                          * If we enforced permissions checks on index support
3530                                          * functions, we'd need to make a check here.  But the
3531                                          * index support machinery doesn't do that, and neither
3532                                          * does this code.
3533                                          */
3534                                         fmgr_info(proc, &(rstate->funcs[i]));
3535                                         i++;
3536                                 }
3537                                 state = (ExprState *) rstate;
3538                         }
3539                         break;
3540                 case T_CoalesceExpr:
3541                         {
3542                                 CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
3543                                 CoalesceExprState *cstate = makeNode(CoalesceExprState);
3544                                 List       *outlist = NIL;
3545                                 ListCell   *l;
3546
3547                                 cstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalCoalesce;
3548                                 foreach(l, coalesceexpr->args)
3549                                 {
3550                                         Expr       *e = (Expr *) lfirst(l);
3551                                         ExprState  *estate;
3552
3553                                         estate = ExecInitExpr(e, parent);
3554                                         outlist = lappend(outlist, estate);
3555                                 }
3556                                 cstate->args = outlist;
3557                                 state = (ExprState *) cstate;
3558                         }
3559                         break;
3560                 case T_MinMaxExpr:
3561                         {
3562                                 MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
3563                                 MinMaxExprState *mstate = makeNode(MinMaxExprState);
3564                                 List       *outlist = NIL;
3565                                 ListCell   *l;
3566                                 TypeCacheEntry *typentry;
3567
3568                                 mstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalMinMax;
3569                                 foreach(l, minmaxexpr->args)
3570                                 {
3571                                         Expr       *e = (Expr *) lfirst(l);
3572                                         ExprState  *estate;
3573
3574                                         estate = ExecInitExpr(e, parent);
3575                                         outlist = lappend(outlist, estate);
3576                                 }
3577                                 mstate->args = outlist;
3578                                 /* Look up the btree comparison function for the datatype */
3579                                 typentry = lookup_type_cache(minmaxexpr->minmaxtype,
3580                                                                                          TYPECACHE_CMP_PROC);
3581                                 if (!OidIsValid(typentry->cmp_proc))
3582                                         ereport(ERROR,
3583                                                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
3584                                                          errmsg("could not identify a comparison function for type %s",
3585                                                                         format_type_be(minmaxexpr->minmaxtype))));
3586                                 /*
3587                                  * If we enforced permissions checks on index support
3588                                  * functions, we'd need to make a check here.  But the
3589                                  * index support machinery doesn't do that, and neither
3590                                  * does this code.
3591                                  */
3592                                 fmgr_info(typentry->cmp_proc, &(mstate->cfunc));
3593                                 state = (ExprState *) mstate;
3594                         }
3595                         break;
3596                 case T_NullIfExpr:
3597                         {
3598                                 NullIfExpr *nullifexpr = (NullIfExpr *) node;
3599                                 FuncExprState *fstate = makeNode(FuncExprState);
3600
3601                                 fstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalNullIf;
3602                                 fstate->args = (List *)
3603                                         ExecInitExpr((Expr *) nullifexpr->args, parent);
3604                                 fstate->func.fn_oid = InvalidOid;               /* not initialized */
3605                                 state = (ExprState *) fstate;
3606                         }
3607                         break;
3608                 case T_NullTest:
3609                         {
3610                                 NullTest   *ntest = (NullTest *) node;
3611                                 GenericExprState *gstate = makeNode(GenericExprState);
3612
3613                                 gstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalNullTest;
3614                                 gstate->arg = ExecInitExpr(ntest->arg, parent);
3615                                 state = (ExprState *) gstate;
3616                         }
3617                         break;
3618                 case T_BooleanTest:
3619                         {
3620                                 BooleanTest *btest = (BooleanTest *) node;
3621                                 GenericExprState *gstate = makeNode(GenericExprState);
3622
3623                                 gstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalBooleanTest;
3624                                 gstate->arg = ExecInitExpr(btest->arg, parent);
3625                                 state = (ExprState *) gstate;
3626                         }
3627                         break;
3628                 case T_CoerceToDomain:
3629                         {
3630                                 CoerceToDomain *ctest = (CoerceToDomain *) node;
3631                                 CoerceToDomainState *cstate = makeNode(CoerceToDomainState);
3632
3633                                 cstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalCoerceToDomain;
3634                                 cstate->arg = ExecInitExpr(ctest->arg, parent);
3635                                 cstate->constraints = GetDomainConstraints(ctest->resulttype);
3636                                 state = (ExprState *) cstate;
3637                         }
3638                         break;
3639                 case T_TargetEntry:
3640                         {
3641                                 TargetEntry *tle = (TargetEntry *) node;
3642                                 GenericExprState *gstate = makeNode(GenericExprState);
3643
3644                                 gstate->xprstate.evalfunc = NULL;               /* not used */
3645                                 gstate->arg = ExecInitExpr(tle->expr, parent);
3646                                 state = (ExprState *) gstate;
3647                         }
3648                         break;
3649                 case T_List:
3650                         {
3651                                 List       *outlist = NIL;
3652                                 ListCell   *l;
3653
3654                                 foreach(l, (List *) node)
3655                                 {
3656                                         outlist = lappend(outlist,
3657                                                                           ExecInitExpr((Expr *) lfirst(l),
3658                                                                                                    parent));
3659                                 }
3660                                 /* Don't fall through to the "common" code below */
3661                                 return (ExprState *) outlist;
3662                         }
3663                 default:
3664                         elog(ERROR, "unrecognized node type: %d",
3665                                  (int) nodeTag(node));
3666                         state = NULL;           /* keep compiler quiet */
3667                         break;
3668         }
3669
3670         /* Common code for all state-node types */
3671         state->expr = node;
3672
3673         return state;
3674 }
3675
3676 /*
3677  * ExecInitExprInitPlan --- initialize a subplan expr that's being handled
3678  * as an InitPlan.      This is identical to ExecInitExpr's handling of a regular
3679  * subplan expr, except we do NOT want to add the node to the parent's
3680  * subplan list.
3681  */
3682 SubPlanState *
3683 ExecInitExprInitPlan(SubPlan *node, PlanState *parent)
3684 {
3685         SubPlanState *sstate = makeNode(SubPlanState);
3686
3687         if (!parent)
3688                 elog(ERROR, "SubPlan found with no parent plan");
3689
3690         /* The subplan's state will be initialized later */
3691         sstate->sub_estate = NULL;
3692         sstate->planstate = NULL;
3693
3694         sstate->testexpr = ExecInitExpr((Expr *) node->testexpr, parent);
3695         sstate->args = (List *) ExecInitExpr((Expr *) node->args, parent);
3696
3697         sstate->xprstate.expr = (Expr *) node;
3698
3699         return sstate;
3700 }
3701
3702 /*
3703  * ExecPrepareExpr --- initialize for expression execution outside a normal
3704  * Plan tree context.
3705  *
3706  * This differs from ExecInitExpr in that we don't assume the caller is
3707  * already running in the EState's per-query context.  Also, we apply
3708  * fix_opfuncids() to the passed expression tree to be sure it is ready
3709  * to run.      (In ordinary Plan trees the planner will have fixed opfuncids,
3710  * but callers outside the executor will not have done this.)
3711  */
3712 ExprState *
3713 ExecPrepareExpr(Expr *node, EState *estate)
3714 {
3715         ExprState  *result;
3716         MemoryContext oldcontext;
3717
3718         fix_opfuncids((Node *) node);
3719
3720         oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
3721
3722         result = ExecInitExpr(node, NULL);
3723
3724         MemoryContextSwitchTo(oldcontext);
3725
3726         return result;
3727 }
3728
3729
3730 /* ----------------------------------------------------------------
3731  *                                       ExecQual / ExecTargetList / ExecProject
3732  * ----------------------------------------------------------------
3733  */
3734
3735 /* ----------------------------------------------------------------
3736  *              ExecQual
3737  *
3738  *              Evaluates a conjunctive boolean expression (qual list) and
3739  *              returns true iff none of the subexpressions are false.
3740  *              (We also return true if the list is empty.)
3741  *
3742  *      If some of the subexpressions yield NULL but none yield FALSE,
3743  *      then the result of the conjunction is NULL (ie, unknown)
3744  *      according to three-valued boolean logic.  In this case,
3745  *      we return the value specified by the "resultForNull" parameter.
3746  *
3747  *      Callers evaluating WHERE clauses should pass resultForNull=FALSE,
3748  *      since SQL specifies that tuples with null WHERE results do not
3749  *      get selected.  On the other hand, callers evaluating constraint
3750  *      conditions should pass resultForNull=TRUE, since SQL also specifies
3751  *      that NULL constraint conditions are not failures.
3752  *
3753  *      NOTE: it would not be correct to use this routine to evaluate an
3754  *      AND subclause of a boolean expression; for that purpose, a NULL
3755  *      result must be returned as NULL so that it can be properly treated
3756  *      in the next higher operator (cf. ExecEvalAnd and ExecEvalOr).
3757  *      This routine is only used in contexts where a complete expression
3758  *      is being evaluated and we know that NULL can be treated the same
3759  *      as one boolean result or the other.
3760  *
3761  * ----------------------------------------------------------------
3762  */
3763 bool
3764 ExecQual(List *qual, ExprContext *econtext, bool resultForNull)
3765 {
3766         bool            result;
3767         MemoryContext oldContext;
3768         ListCell   *l;
3769
3770         /*
3771          * debugging stuff
3772          */
3773         EV_printf("ExecQual: qual is ");
3774         EV_nodeDisplay(qual);
3775         EV_printf("\n");
3776
3777         IncrProcessed();
3778
3779         /*
3780          * Run in short-lived per-tuple context while computing expressions.
3781          */
3782         oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
3783
3784         /*
3785          * Evaluate the qual conditions one at a time.  If we find a FALSE result,
3786          * we can stop evaluating and return FALSE --- the AND result must be
3787          * FALSE.  Also, if we find a NULL result when resultForNull is FALSE, we
3788          * can stop and return FALSE --- the AND result must be FALSE or NULL in
3789          * that case, and the caller doesn't care which.
3790          *
3791          * If we get to the end of the list, we can return TRUE.  This will happen
3792          * when the AND result is indeed TRUE, or when the AND result is NULL (one
3793          * or more NULL subresult, with all the rest TRUE) and the caller has
3794          * specified resultForNull = TRUE.
3795          */
3796         result = true;
3797
3798         foreach(l, qual)
3799         {
3800                 ExprState  *clause = (ExprState *) lfirst(l);
3801                 Datum           expr_value;
3802                 bool            isNull;
3803
3804                 expr_value = ExecEvalExpr(clause, econtext, &isNull, NULL);
3805
3806                 if (isNull)
3807                 {
3808                         if (resultForNull == false)
3809                         {
3810                                 result = false; /* treat NULL as FALSE */
3811                                 break;
3812                         }
3813                 }
3814                 else
3815                 {
3816                         if (!DatumGetBool(expr_value))
3817                         {
3818                                 result = false; /* definitely FALSE */
3819                                 break;
3820                         }
3821                 }
3822         }
3823
3824         MemoryContextSwitchTo(oldContext);
3825
3826         return result;
3827 }
3828
3829 /*
3830  * Number of items in a tlist (including any resjunk items!)
3831  */
3832 int
3833 ExecTargetListLength(List *targetlist)
3834 {
3835         /* This used to be more complex, but fjoins are dead */
3836         return list_length(targetlist);
3837 }
3838
3839 /*
3840  * Number of items in a tlist, not including any resjunk items
3841  */
3842 int
3843 ExecCleanTargetListLength(List *targetlist)
3844 {
3845         int                     len = 0;
3846         ListCell   *tl;
3847
3848         foreach(tl, targetlist)
3849         {
3850                 TargetEntry *curTle = (TargetEntry *) lfirst(tl);
3851
3852                 Assert(IsA(curTle, TargetEntry));
3853                 if (!curTle->resjunk)
3854                         len++;
3855         }
3856         return len;
3857 }
3858
3859 /*
3860  * ExecTargetList
3861  *              Evaluates a targetlist with respect to the given
3862  *              expression context.  Returns TRUE if we were able to create
3863  *              a result, FALSE if we have exhausted a set-valued expression.
3864  *
3865  * Results are stored into the passed values and isnull arrays.
3866  * The caller must provide an itemIsDone array that persists across calls.
3867  *
3868  * As with ExecEvalExpr, the caller should pass isDone = NULL if not
3869  * prepared to deal with sets of result tuples.  Otherwise, a return
3870  * of *isDone = ExprMultipleResult signifies a set element, and a return
3871  * of *isDone = ExprEndResult signifies end of the set of tuple.
3872  */
3873 static bool
3874 ExecTargetList(List *targetlist,
3875                            ExprContext *econtext,
3876                            Datum *values,
3877                            bool *isnull,
3878                            ExprDoneCond *itemIsDone,
3879                            ExprDoneCond *isDone)
3880 {
3881         MemoryContext oldContext;
3882         ListCell   *tl;
3883         bool            haveDoneSets;
3884
3885         /*
3886          * Run in short-lived per-tuple context while computing expressions.
3887          */
3888         oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
3889
3890         /*
3891          * evaluate all the expressions in the target list
3892          */
3893         if (isDone)
3894                 *isDone = ExprSingleResult;             /* until proven otherwise */
3895
3896         haveDoneSets = false;           /* any exhausted set exprs in tlist? */
3897
3898         foreach(tl, targetlist)
3899         {
3900                 GenericExprState *gstate = (GenericExprState *) lfirst(tl);
3901                 TargetEntry *tle = (TargetEntry *) gstate->xprstate.expr;
3902                 AttrNumber      resind = tle->resno - 1;
3903
3904                 values[resind] = ExecEvalExpr(gstate->arg,
3905                                                                           econtext,
3906                                                                           &isnull[resind],
3907                                                                           &itemIsDone[resind]);
3908
3909                 if (itemIsDone[resind] != ExprSingleResult)
3910                 {
3911                         /* We have a set-valued expression in the tlist */
3912                         if (isDone == NULL)
3913                                 ereport(ERROR,
3914                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3915                                                  errmsg("set-valued function called in context that cannot accept a set")));
3916                         if (itemIsDone[resind] == ExprMultipleResult)
3917                         {
3918                                 /* we have undone sets in the tlist, set flag */
3919                                 *isDone = ExprMultipleResult;
3920                         }
3921                         else
3922                         {
3923                                 /* we have done sets in the tlist, set flag for that */
3924                                 haveDoneSets = true;
3925                         }
3926                 }
3927         }
3928
3929         if (haveDoneSets)
3930         {
3931                 /*
3932                  * note: can't get here unless we verified isDone != NULL
3933                  */
3934                 if (*isDone == ExprSingleResult)
3935                 {
3936                         /*
3937                          * all sets are done, so report that tlist expansion is complete.
3938                          */
3939                         *isDone = ExprEndResult;
3940                         MemoryContextSwitchTo(oldContext);
3941                         return false;
3942                 }
3943                 else
3944                 {
3945                         /*
3946                          * We have some done and some undone sets.      Restart the done ones
3947                          * so that we can deliver a tuple (if possible).
3948                          */
3949                         foreach(tl, targetlist)
3950                         {
3951                                 GenericExprState *gstate = (GenericExprState *) lfirst(tl);
3952                                 TargetEntry *tle = (TargetEntry *) gstate->xprstate.expr;
3953                                 AttrNumber      resind = tle->resno - 1;
3954
3955                                 if (itemIsDone[resind] == ExprEndResult)
3956                                 {
3957                                         values[resind] = ExecEvalExpr(gstate->arg,
3958                                                                                                   econtext,
3959                                                                                                   &isnull[resind],
3960                                                                                                   &itemIsDone[resind]);
3961
3962                                         if (itemIsDone[resind] == ExprEndResult)
3963                                         {
3964                                                 /*
3965                                                  * Oh dear, this item is returning an empty set. Guess
3966                                                  * we can't make a tuple after all.
3967                                                  */
3968                                                 *isDone = ExprEndResult;
3969                                                 break;
3970                                         }
3971                                 }
3972                         }
3973
3974                         /*
3975                          * If we cannot make a tuple because some sets are empty, we still
3976                          * have to cycle the nonempty sets to completion, else resources
3977                          * will not be released from subplans etc.
3978                          *
3979                          * XXX is that still necessary?
3980                          */
3981                         if (*isDone == ExprEndResult)
3982                         {
3983                                 foreach(tl, targetlist)
3984                                 {
3985                                         GenericExprState *gstate = (GenericExprState *) lfirst(tl);
3986                                         TargetEntry *tle = (TargetEntry *) gstate->xprstate.expr;
3987                                         AttrNumber      resind = tle->resno - 1;
3988
3989                                         while (itemIsDone[resind] == ExprMultipleResult)
3990                                         {
3991                                                 values[resind] = ExecEvalExpr(gstate->arg,
3992                                                                                                           econtext,
3993                                                                                                           &isnull[resind],
3994                                                                                                           &itemIsDone[resind]);
3995                                         }
3996                                 }
3997
3998                                 MemoryContextSwitchTo(oldContext);
3999                                 return false;
4000                         }
4001                 }
4002         }
4003
4004         /* Report success */
4005         MemoryContextSwitchTo(oldContext);
4006
4007         return true;
4008 }
4009
4010 /*
4011  * ExecVariableList
4012  *              Evaluates a simple-Variable-list projection.
4013  *
4014  * Results are stored into the passed values and isnull arrays.
4015  */
4016 static void
4017 ExecVariableList(ProjectionInfo *projInfo,
4018                                  Datum *values,
4019                                  bool *isnull)
4020 {
4021         ExprContext *econtext = projInfo->pi_exprContext;
4022         int                *varSlotOffsets = projInfo->pi_varSlotOffsets;
4023         int                *varNumbers = projInfo->pi_varNumbers;
4024         int                     i;
4025
4026         /*
4027          * Force extraction of all input values that we need.
4028          */
4029         if (projInfo->pi_lastInnerVar > 0)
4030                 slot_getsomeattrs(econtext->ecxt_innertuple,
4031                                                   projInfo->pi_lastInnerVar);
4032         if (projInfo->pi_lastOuterVar > 0)
4033                 slot_getsomeattrs(econtext->ecxt_outertuple,
4034                                                   projInfo->pi_lastOuterVar);
4035         if (projInfo->pi_lastScanVar > 0)
4036                 slot_getsomeattrs(econtext->ecxt_scantuple,
4037                                                   projInfo->pi_lastScanVar);
4038
4039         /*
4040          * Assign to result by direct extraction of fields from source slots ... a
4041          * mite ugly, but fast ...
4042          */
4043         for (i = list_length(projInfo->pi_targetlist) - 1; i >= 0; i--)
4044         {
4045                 char       *slotptr = ((char *) econtext) + varSlotOffsets[i];
4046                 TupleTableSlot *varSlot = *((TupleTableSlot **) slotptr);
4047                 int                     varNumber = varNumbers[i] - 1;
4048
4049                 values[i] = varSlot->tts_values[varNumber];
4050                 isnull[i] = varSlot->tts_isnull[varNumber];
4051         }
4052 }
4053
4054 /*
4055  * ExecProject
4056  *
4057  *              projects a tuple based on projection info and stores
4058  *              it in the previously specified tuple table slot.
4059  *
4060  *              Note: the result is always a virtual tuple; therefore it
4061  *              may reference the contents of the exprContext's scan tuples
4062  *              and/or temporary results constructed in the exprContext.
4063  *              If the caller wishes the result to be valid longer than that
4064  *              data will be valid, he must call ExecMaterializeSlot on the
4065  *              result slot.
4066  */
4067 TupleTableSlot *
4068 ExecProject(ProjectionInfo *projInfo, ExprDoneCond *isDone)
4069 {
4070         TupleTableSlot *slot;
4071
4072         /*
4073          * sanity checks
4074          */
4075         Assert(projInfo != NULL);
4076
4077         /*
4078          * get the projection info we want
4079          */
4080         slot = projInfo->pi_slot;
4081
4082         /*
4083          * Clear any former contents of the result slot.  This makes it safe for
4084          * us to use the slot's Datum/isnull arrays as workspace. (Also, we can
4085          * return the slot as-is if we decide no rows can be projected.)
4086          */
4087         ExecClearTuple(slot);
4088
4089         /*
4090          * form a new result tuple (if possible); if successful, mark the result
4091          * slot as containing a valid virtual tuple
4092          */
4093         if (projInfo->pi_isVarList)
4094         {
4095                 /* simple Var list: this always succeeds with one result row */
4096                 if (isDone)
4097                         *isDone = ExprSingleResult;
4098                 ExecVariableList(projInfo,
4099                                                  slot->tts_values,
4100                                                  slot->tts_isnull);
4101                 ExecStoreVirtualTuple(slot);
4102         }
4103         else
4104         {
4105                 if (ExecTargetList(projInfo->pi_targetlist,
4106                                                    projInfo->pi_exprContext,
4107                                                    slot->tts_values,
4108                                                    slot->tts_isnull,
4109                                                    projInfo->pi_itemIsDone,
4110                                                    isDone))
4111                         ExecStoreVirtualTuple(slot);
4112         }
4113
4114         return slot;
4115 }