/* * Evaluate the limit/offset expressions --- done at start of each scan. * * This is also a handy place to reset the current-position state info. */ static void recompute_limits(LimitState *node) { ExprContext *econtext = node->ps.ps_ExprContext; Datum val; bool isNull; if (node->limitOffset) { val = ExecEvalExprSwitchContext(node->limitOffset, econtext, &isNull, NULL); /* Interpret NULL offset as no offset */ if (isNull) node->offset = 0; else { node->offset = DatumGetInt64(val); if (node->offset < 0) node->offset = 0; } } else { /* No OFFSET supplied */ node->offset = 0; } if (node->limitCount) { val = ExecEvalExprSwitchContext(node->limitCount, econtext, &isNull, NULL); /* Interpret NULL count as no count (LIMIT ALL) */ if (isNull) { node->count = 0; node->noCount = true; } else { node->count = DatumGetInt64(val); if (node->count < 0) node->count = 0; node->noCount = false; } } else { /* No COUNT supplied */ node->count = 0; node->noCount = true; } /* Reset position to start-of-scan */ node->position = 0; node->subSlot = NULL; }
/* * Evaluates a list of parameters, using the given executor state. It * requires a list of the parameter values themselves, and a list of * their types. It returns a filled-in ParamListInfo -- this can later * be passed to CreateQueryDesc(), which allows the executor to make use * of the parameters during query execution. */ static ParamListInfo EvaluateParams(EState *estate, List *params, List *argtypes) { int nargs = length(argtypes); ParamListInfo paramLI; List *exprstates; List *l; int i = 0; /* Parser should have caught this error, but check for safety */ if (length(params) != nargs) elog(ERROR, "wrong number of arguments"); exprstates = (List *) ExecPrepareExpr((Expr *) params, estate); paramLI = (ParamListInfo) palloc0((nargs + 1) * sizeof(ParamListInfoData)); foreach(l, exprstates) { ExprState *n = lfirst(l); bool isNull; paramLI[i].value = ExecEvalExprSwitchContext(n, GetPerTupleExprContext(estate), &isNull, NULL); paramLI[i].kind = PARAM_NUM; paramLI[i].id = i + 1; paramLI[i].isnull = isNull; i++; }
/* ---------------- * FormIndexDatum * Construct Datum[] and nullv[] arrays for a new index tuple. * * indexInfo Info about the index * heapTuple Heap tuple for which we must prepare an index entry * heapDescriptor tupledesc for heap tuple * estate executor state for evaluating any index expressions * datum Array of index Datums (output area) * nullv Array of is-null indicators (output area) * * When there are no index expressions, estate may be NULL. Otherwise it * must be supplied, *and* the ecxt_scantuple slot of its per-tuple expr * context must point to the heap tuple passed in. * * For largely historical reasons, we don't actually call index_formtuple() * here, we just prepare its input arrays datum[] and nullv[]. * ---------------- */ void FormIndexDatum(IndexInfo *indexInfo, HeapTuple heapTuple, TupleDesc heapDescriptor, EState *estate, Datum *datum, char *nullv) { List *indexprs; int i; if (indexInfo->ii_Expressions != NIL && indexInfo->ii_ExpressionsState == NIL) { /* First time through, set up expression evaluation state */ indexInfo->ii_ExpressionsState = (List *) ExecPrepareExpr((Expr *) indexInfo->ii_Expressions, estate); /* Check caller has set up context correctly */ Assert(GetPerTupleExprContext(estate)->ecxt_scantuple->val == heapTuple); } indexprs = indexInfo->ii_ExpressionsState; for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++) { int keycol = indexInfo->ii_KeyAttrNumbers[i]; Datum iDatum; bool isNull; if (keycol != 0) { /* * Plain index column; get the value we need directly from the * heap tuple. */ iDatum = heap_getattr(heapTuple, keycol, heapDescriptor, &isNull); } else { /* * Index expression --- need to evaluate it. */ if (indexprs == NIL) elog(ERROR, "wrong number of index expressions"); iDatum = ExecEvalExprSwitchContext((ExprState *) lfirst(indexprs), GetPerTupleExprContext(estate), &isNull, NULL); indexprs = lnext(indexprs); } datum[i] = iDatum; nullv[i] = (isNull) ? 'n' : ' '; } if (indexprs != NIL) elog(ERROR, "wrong number of index expressions"); }
/* * Evaluates a list of parameters, using the given executor state. It * requires a list of the parameter expressions themselves, and a list of * their types. It returns a filled-in ParamListInfo -- this can later * be passed to CreateQueryDesc(), which allows the executor to make use * of the parameters during query execution. */ static ParamListInfo EvaluateParams(EState *estate, List *params, List *argtypes) { int nargs = list_length(argtypes); ParamListInfo paramLI; List *exprstates; ListCell *le, *la; int i = 0; /* Parser should have caught this error, but check for safety */ if (list_length(params) != nargs) elog(ERROR, "wrong number of arguments"); if (nargs == 0) return NULL; exprstates = (List *) ExecPrepareExpr((Expr *) params, estate); /* sizeof(ParamListInfoData) includes the first array element */ paramLI = (ParamListInfo) palloc(sizeof(ParamListInfoData) + (nargs - 1) *sizeof(ParamExternData)); paramLI->numParams = nargs; forboth(le, exprstates, la, argtypes) { ExprState *n = lfirst(le); ParamExternData *prm = ¶mLI->params[i]; prm->ptype = lfirst_oid(la); prm->pflags = 0; prm->value = ExecEvalExprSwitchContext(n, GetPerTupleExprContext(estate), &prm->isnull, NULL); i++; }
/* * ExecIndexEvalRuntimeKeys * Evaluate any runtime key values, and update the scankeys. */ void ExecIndexEvalRuntimeKeys(ExprContext *econtext, IndexRuntimeKeyInfo *runtimeKeys, int numRuntimeKeys) { int j; for (j = 0; j < numRuntimeKeys; j++) { ScanKey scan_key = runtimeKeys[j].scan_key; ExprState *key_expr = runtimeKeys[j].key_expr; Datum scanvalue; bool isNull; /* * For each run-time key, extract the run-time expression and evaluate * it with respect to the current outer tuple. We then stick the * result into the proper scan key. * * Note: the result of the eval could be a pass-by-ref value that's * stored in the outer scan's tuple, not in * econtext->ecxt_per_tuple_memory. We assume that the outer tuple * will stay put throughout our scan. If this is wrong, we could copy * the result into our context explicitly, but I think that's not * necessary... */ scanvalue = ExecEvalExprSwitchContext(key_expr, econtext, &isNull, NULL); scan_key->sk_argument = scanvalue; if (isNull) scan_key->sk_flags |= SK_ISNULL; else scan_key->sk_flags &= ~SK_ISNULL; } }
/* * Compute the list of TIDs to be visited, by evaluating the expressions * for them. * * (The result is actually an array, not a list.) */ static void TidListCreate(TidScanState *tidstate) { List *evalList = tidstate->tss_tidquals; ExprContext *econtext = tidstate->ss.ps.ps_ExprContext; BlockNumber nblocks; ItemPointerData *tidList; int numAllocTids; int numTids; ListCell *l; /* * We silently discard any TIDs that are out of range at the time of scan * start. (Since we hold at least AccessShareLock on the table, it won't * be possible for someone to truncate away the blocks we intend to * visit.) */ nblocks = RelationGetNumberOfBlocks(tidstate->ss.ss_currentRelation); /* * We initialize the array with enough slots for the case that all quals * are simple OpExprs or CurrentOfExprs. If there are any * ScalarArrayOpExprs, we may have to enlarge the array. */ numAllocTids = list_length(evalList); tidList = (ItemPointerData *) palloc(numAllocTids * sizeof(ItemPointerData)); numTids = 0; tidstate->tss_isCurrentOf = false; foreach(l, evalList) { ExprState *exstate = (ExprState *) lfirst(l); Expr *expr = exstate->expr; ItemPointer itemptr; bool isNull; if (is_opclause(expr)) { FuncExprState *fexstate = (FuncExprState *) exstate; Node *arg1; Node *arg2; arg1 = get_leftop(expr); arg2 = get_rightop(expr); if (IsCTIDVar(arg1)) exstate = (ExprState *) lsecond(fexstate->args); else if (IsCTIDVar(arg2)) exstate = (ExprState *) linitial(fexstate->args); else elog(ERROR, "could not identify CTID variable"); itemptr = (ItemPointer) DatumGetPointer(ExecEvalExprSwitchContext(exstate, econtext, &isNull, NULL)); if (!isNull && ItemPointerIsValid(itemptr) && ItemPointerGetBlockNumber(itemptr) < nblocks) { if (numTids >= numAllocTids) { numAllocTids *= 2; tidList = (ItemPointerData *) repalloc(tidList, numAllocTids * sizeof(ItemPointerData)); } tidList[numTids++] = *itemptr; } } else if (expr && IsA(expr, ScalarArrayOpExpr)) { ScalarArrayOpExprState *saexstate = (ScalarArrayOpExprState *) exstate; Datum arraydatum; ArrayType *itemarray; Datum *ipdatums; bool *ipnulls; int ndatums; int i; exstate = (ExprState *) lsecond(saexstate->fxprstate.args); arraydatum = ExecEvalExprSwitchContext(exstate, econtext, &isNull, NULL); if (isNull) continue; itemarray = DatumGetArrayTypeP(arraydatum); deconstruct_array(itemarray, TIDOID, SizeOfIptrData, false, 's', &ipdatums, &ipnulls, &ndatums); if (numTids + ndatums > numAllocTids) { numAllocTids = numTids + ndatums; tidList = (ItemPointerData *) repalloc(tidList, numAllocTids * sizeof(ItemPointerData)); } for (i = 0; i < ndatums; i++) { if (!ipnulls[i]) { itemptr = (ItemPointer) DatumGetPointer(ipdatums[i]); if (ItemPointerIsValid(itemptr) && ItemPointerGetBlockNumber(itemptr) < nblocks) tidList[numTids++] = *itemptr; } } pfree(ipdatums); pfree(ipnulls); } else if (expr && IsA(expr, CurrentOfExpr)) { CurrentOfExpr *cexpr = (CurrentOfExpr *) expr; ItemPointerData cursor_tid; if (execCurrentOf(cexpr, econtext, RelationGetRelid(tidstate->ss.ss_currentRelation), &cursor_tid)) { if (numTids >= numAllocTids) { numAllocTids *= 2; tidList = (ItemPointerData *) repalloc(tidList, numAllocTids * sizeof(ItemPointerData)); } tidList[numTids++] = cursor_tid; tidstate->tss_isCurrentOf = true; } } else elog(ERROR, "could not identify CTID expression"); }
/* * Evaluate the limit/offset expressions --- done at startup or rescan. * * This is also a handy place to reset the current-position state info. */ static void recompute_limits(LimitState *node) { ExprContext *econtext = node->ps.ps_ExprContext; Datum val; bool isNull; if (node->limitOffset) { val = ExecEvalExprSwitchContext(node->limitOffset, econtext, &isNull, NULL); /* Interpret NULL offset as no offset */ if (isNull) node->offset = 0; else { node->offset = DatumGetInt64(val); if (node->offset < 0) node->offset = 0; } } else { /* No OFFSET supplied */ node->offset = 0; } if (node->limitCount) { val = ExecEvalExprSwitchContext(node->limitCount, econtext, &isNull, NULL); /* Interpret NULL count as no count (LIMIT ALL) */ if (isNull) { node->count = 0; node->noCount = true; } else { node->count = DatumGetInt64(val); if (node->count < 0) node->count = 0; node->noCount = false; } } else { /* No COUNT supplied */ node->count = 0; node->noCount = true; } /* Reset position to start-of-scan */ node->position = 0; node->subSlot = NULL; /* Set state-machine state */ node->lstate = LIMIT_RESCAN; /* * If we have a COUNT, and our input is a Sort node, notify it that it can * use bounded sort. * * This is a bit of a kluge, but we don't have any more-abstract way of * communicating between the two nodes; and it doesn't seem worth trying * to invent one without some more examples of special communication * needs. * * Note: it is the responsibility of nodeSort.c to react properly to * changes of these parameters. If we ever do redesign this, it'd be a * good idea to integrate this signaling with the parameter-change * mechanism. */ if (IsA(outerPlanState(node), SortState)) { SortState *sortState = (SortState *) outerPlanState(node); int64 tuples_needed = node->count + node->offset; /* negative test checks for overflow */ if (node->noCount || tuples_needed < 0 || !gp_enable_sort_limit) { /* make sure flag gets reset if needed upon rescan */ sortState->bounded = false; } else { sortState->bounded = true; sortState->bound = tuples_needed; } } }
/* ---------------------------------------------------------------- * ExecSort * * Sorts tuples from the outer subtree of the node using tuplesort, * which saves the results in a temporary file or memory. After the * initial call, returns a tuple from the file with each call. * * Conditions: * -- none. * * Initial States: * -- the outer child is prepared to return the first tuple. * ---------------------------------------------------------------- */ TupleTableSlot * ExecSort(SortState *node) { EState *estate; ScanDirection dir; Tuplesortstate *tuplesortstate = NULL; Tuplesortstate_mk *tuplesortstate_mk = NULL; TupleTableSlot *slot = NULL; Sort *plannode = NULL; PlanState *outerNode = NULL; TupleDesc tupDesc = NULL; workfile_set *work_set = NULL; /* * get state info from node */ SO1_printf("ExecSort: %s\n", "entering routine"); estate = node->ss.ps.state; dir = estate->es_direction; if(gp_enable_mk_sort) { tuplesortstate_mk = node->tuplesortstate->sortstore_mk; } else { tuplesortstate = node->tuplesortstate->sortstore; } /* * In Window node, we might need to call ExecSort again even when * the last tuple in the Sort has been retrieved. Since we might * eager free the tuplestore, the tuplestorestate could be NULL. * We simply return NULL in this case. */ if (node->sort_Done && ((gp_enable_mk_sort && tuplesortstate_mk == NULL) || (!gp_enable_mk_sort && tuplesortstate == NULL))) { return NULL; } plannode = (Sort *) node->ss.ps.plan; /* * If called for the first time, initialize tuplesort_state */ if (!node->sort_Done) { SO1_printf("ExecSort: %s\n", "sorting subplan"); if (gp_workfile_caching) { /* Look for cached workfile set. Mark here if found */ work_set = workfile_mgr_find_set(&node->ss.ps); if (work_set != NULL) { elog(gp_workfile_caching_loglevel, "Sort found matching cached workfile set"); node->cached_workfiles_found = true; } } /* * Want to scan subplan in the forward direction while creating the * sorted data. */ estate->es_direction = ForwardScanDirection; /* * Initialize tuplesort module. */ SO1_printf("ExecSort: %s\n", "calling tuplesort_begin"); outerNode = outerPlanState(node); tupDesc = ExecGetResultType(outerNode); if(plannode->share_type == SHARE_SORT_XSLICE) { char rwfile_prefix[100]; if(plannode->driver_slice != currentSliceId) { elog(LOG, "Sort exec on CrossSlice, current slice %d", currentSliceId); return NULL; } shareinput_create_bufname_prefix(rwfile_prefix, sizeof(rwfile_prefix), plannode->share_id); elog(LOG, "Sort node create shareinput rwfile %s", rwfile_prefix); if(gp_enable_mk_sort) tuplesortstate_mk = tuplesort_begin_heap_file_readerwriter_mk( & node->ss, rwfile_prefix, true, tupDesc, plannode->numCols, plannode->sortOperators, plannode->sortColIdx, PlanStateOperatorMemKB((PlanState *) node), true ); else tuplesortstate = tuplesort_begin_heap_file_readerwriter( rwfile_prefix, true, tupDesc, plannode->numCols, plannode->sortOperators, plannode->sortColIdx, PlanStateOperatorMemKB((PlanState *) node), true ); } else { if(gp_enable_mk_sort) tuplesortstate_mk = tuplesort_begin_heap_mk(& node->ss, tupDesc, plannode->numCols, plannode->sortOperators, plannode->sortColIdx, PlanStateOperatorMemKB((PlanState *) node), node->randomAccess); else tuplesortstate = tuplesort_begin_heap(tupDesc, plannode->numCols, plannode->sortOperators, plannode->sortColIdx, PlanStateOperatorMemKB((PlanState *) node), node->randomAccess); } if(gp_enable_mk_sort) { node->tuplesortstate->sortstore_mk = tuplesortstate_mk; } else { node->tuplesortstate->sortstore = tuplesortstate; } /* CDB */ { ExprContext *econtext = node->ss.ps.ps_ExprContext; bool isNull; int64 limit = 0; int64 offset = 0; int unique = 0; int sort_flags = gp_sort_flags; /* get the guc */ int maxdistinct = gp_sort_max_distinct; /* get the guc */ if (node->limitCount) { limit = DatumGetInt64( ExecEvalExprSwitchContext(node->limitCount, econtext, &isNull, NULL)); /* Interpret NULL limit as no limit */ if (isNull) limit = 0; else if (limit < 0) limit = 0; } if (node->limitOffset) { offset = DatumGetInt64( ExecEvalExprSwitchContext(node->limitOffset, econtext, &isNull, NULL)); /* Interpret NULL offset as no offset */ if (isNull) offset = 0; else if (offset < 0) offset = 0; } if (node->noduplicates) unique = 1; if(gp_enable_mk_sort) cdb_tuplesort_init_mk(tuplesortstate_mk, offset, limit, unique, sort_flags, maxdistinct); else cdb_tuplesort_init(tuplesortstate, offset, limit, unique, sort_flags, maxdistinct); } /* If EXPLAIN ANALYZE, share our Instrumentation object with sort. */ if(gp_enable_mk_sort) { if (node->ss.ps.instrument) tuplesort_set_instrument_mk(tuplesortstate_mk, node->ss.ps.instrument, node->ss.ps.cdbexplainbuf); tuplesort_set_gpmon_mk(tuplesortstate_mk, &node->ss.ps.gpmon_pkt, &node->ss.ps.gpmon_plan_tick); } else { if (node->ss.ps.instrument) tuplesort_set_instrument(tuplesortstate, node->ss.ps.instrument, node->ss.ps.cdbexplainbuf); tuplesort_set_gpmon(tuplesortstate, &node->ss.ps.gpmon_pkt, &node->ss.ps.gpmon_plan_tick); } } /* * Before reading any tuples from below, check if we can re-use * existing spill files. * Only mk_sort supports spill file caching. */ if (!node->sort_Done && gp_enable_mk_sort && gp_workfile_caching) { Assert(tuplesortstate_mk != NULL); if (node->cached_workfiles_found && !node->cached_workfiles_loaded) { Assert(work_set != NULL); elog(gp_workfile_caching_loglevel, "nodeSort: loading cached workfile metadata"); tuplesort_set_spillfile_set_mk(tuplesortstate_mk, work_set); tuplesort_read_spill_metadata_mk(tuplesortstate_mk); node->cached_workfiles_loaded = true; if (node->ss.ps.instrument) { node->ss.ps.instrument->workfileReused = true; } /* Loaded sorted data from cached workfile, therefore * no need to sort anymore! */ node->sort_Done = true; elog(gp_workfile_caching_loglevel, "Sort reusing cached workfiles, initiating Squelch walker"); ExecSquelchNode(outerNode); } } /* * If first time through and no cached workfiles can be used, * read all tuples from outer plan and pass them to * tuplesort.c. Subsequent calls just fetch tuples from tuplesort. */ if (!node->sort_Done) { Assert(outerNode != NULL); /* * Scan the subplan and feed all the tuples to tuplesort. */ for (;;) { slot = ExecProcNode(outerNode); if (TupIsNull(slot)) { break; } CheckSendPlanStateGpmonPkt(&node->ss.ps); if(gp_enable_mk_sort) tuplesort_puttupleslot_mk(tuplesortstate_mk, slot); else tuplesort_puttupleslot(tuplesortstate, slot); } #ifdef FAULT_INJECTOR FaultInjector_InjectFaultIfSet( ExecSortBeforeSorting, DDLNotSpecified, "" /* databaseName */, "" /* tableName */ ); #endif /* * Complete the sort. */ if(gp_enable_mk_sort) { tuplesort_performsort_mk(tuplesortstate_mk); } else { tuplesort_performsort(tuplesortstate); } CheckSendPlanStateGpmonPkt(&node->ss.ps); /* * restore to user specified direction */ estate->es_direction = dir; /* * finally set the sorted flag to true */ node->sort_Done = true; SO1_printf("ExecSort: %s\n", "sorting done"); /* for share input, do not need to return any tuple */ if(plannode->share_type != SHARE_NOTSHARED) { Assert(plannode->share_type == SHARE_SORT || plannode->share_type == SHARE_SORT_XSLICE); if(plannode->share_type == SHARE_SORT_XSLICE) { if(plannode->driver_slice == currentSliceId) { if(gp_enable_mk_sort) tuplesort_flush_mk(tuplesortstate_mk); else tuplesort_flush(tuplesortstate); node->share_lk_ctxt = shareinput_writer_notifyready(plannode->share_id, plannode->nsharer_xslice, estate->es_plannedstmt->planGen); } } return NULL; } } /* if (!node->sort_Done) */ if(plannode->share_type != SHARE_NOTSHARED) return NULL; SO1_printf("ExecSort: %s\n", "retrieving tuple from tuplesort"); /* * Get the first or next tuple from tuplesort. Returns NULL if no more * tuples. */ slot = node->ss.ps.ps_ResultTupleSlot; if(gp_enable_mk_sort) (void) tuplesort_gettupleslot_mk(tuplesortstate_mk, ScanDirectionIsForward(dir), slot); else (void) tuplesort_gettupleslot(tuplesortstate, ScanDirectionIsForward(dir), slot); if (TupIsNull(slot) && !node->ss.ps.delayEagerFree) { ExecEagerFreeSort(node); } return slot; }
LimitPlanState *DMLUtils::PrepareLimitState(LimitState *limit_plan_state) { LimitPlanState *info = (LimitPlanState *)palloc(sizeof(LimitPlanState)); info->type = limit_plan_state->ps.type; ExprContext *econtext = limit_plan_state->ps.ps_ExprContext; Datum val; bool isNull; int64 limit; int64 offset; bool noLimit; bool noOffset; /* Resolve limit and offset */ if (limit_plan_state->limitOffset) { val = ExecEvalExprSwitchContext(limit_plan_state->limitOffset, econtext, &isNull, NULL); /* Interpret NULL offset as no offset */ if (isNull) offset = 0; else { offset = DatumGetInt64(val); if (offset < 0) { LOG_ERROR("OFFSET must not be negative, offset = %ld", offset); } noOffset = false; } } else { /* No OFFSET supplied */ offset = 0; } if (limit_plan_state->limitCount) { val = ExecEvalExprSwitchContext(limit_plan_state->limitCount, econtext, &isNull, NULL); /* Interpret NULL count as no limit (LIMIT ALL) */ if (isNull) { limit = 0; noLimit = true; } else { limit = DatumGetInt64(val); if (limit < 0) { LOG_ERROR("LIMIT must not be negative, limit = %ld", limit); } noLimit = false; } } else { /* No LIMIT supplied */ limit = 0; noLimit = true; } info->limit = limit; info->offset = offset; info->noLimit = noLimit; info->noOffset = noOffset; PlanState *outer_plan_state = outerPlanState(limit_plan_state); AbstractPlanState *child_plan_state = PreparePlanState(nullptr, outer_plan_state, true); outerAbstractPlanState(info) = child_plan_state; return info; }
/* * Evaluate the limit/offset expressions --- done at startup or rescan. * * This is also a handy place to reset the current-position state info. */ static void recompute_limits(LimitState *node) { ExprContext *econtext = node->ps.ps_ExprContext; Datum val; bool isNull; if (node->limitOffset) { val = ExecEvalExprSwitchContext(node->limitOffset, econtext, &isNull); /* Interpret NULL offset as no offset */ if (isNull) node->offset = 0; else { node->offset = DatumGetInt64(val); if (node->offset < 0) ereport(ERROR, (errcode(ERRCODE_INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE), errmsg("OFFSET must not be negative"))); } } else { /* No OFFSET supplied */ node->offset = 0; } if (node->limitCount) { val = ExecEvalExprSwitchContext(node->limitCount, econtext, &isNull); /* Interpret NULL count as no count (LIMIT ALL) */ if (isNull) { node->count = 0; node->noCount = true; } else { node->count = DatumGetInt64(val); if (node->count < 0) ereport(ERROR, (errcode(ERRCODE_INVALID_ROW_COUNT_IN_LIMIT_CLAUSE), errmsg("LIMIT must not be negative"))); node->noCount = false; } } else { /* No COUNT supplied */ node->count = 0; node->noCount = true; } /* Reset position to start-of-scan */ node->position = 0; node->subSlot = NULL; /* Set state-machine state */ node->lstate = LIMIT_RESCAN; /* Notify child node about limit, if useful */ pass_down_bound(node, outerPlanState(node)); }
/* * Copied from Postgres' src/backend/optimizer/util/clauses.c * * evaluate_expr: pre-evaluate a constant expression * * We use the executor's routine ExecEvalExpr() to avoid duplication of * code and ensure we get the same result as the executor would get. */ Expr * evaluate_expr(Expr *expr, Oid result_type, int32 result_typmod, Oid result_collation) { EState *estate; ExprState *exprstate; MemoryContext oldcontext; Datum const_val; bool const_is_null; int16 resultTypLen; bool resultTypByVal; /* * To use the executor, we need an EState. */ estate = CreateExecutorState(); /* We can use the estate's working context to avoid memory leaks. */ oldcontext = MemoryContextSwitchTo(estate->es_query_cxt); /* Make sure any opfuncids are filled in. */ fix_opfuncids((Node *) expr); /* * Prepare expr for execution. (Note: we can't use ExecPrepareExpr * because it'd result in recursively invoking eval_const_expressions.) */ exprstate = ExecInitExpr(expr, NULL); /* * And evaluate it. * * It is OK to use a default econtext because none of the ExecEvalExpr() * code used in this situation will use econtext. That might seem * fortuitous, but it's not so unreasonable --- a constant expression does * not depend on context, by definition, n'est ce pas? */ const_val = ExecEvalExprSwitchContext(exprstate, GetPerTupleExprContext(estate), &const_is_null, NULL); /* Get info needed about result datatype */ get_typlenbyval(result_type, &resultTypLen, &resultTypByVal); /* Get back to outer memory context */ MemoryContextSwitchTo(oldcontext); /* * Must copy result out of sub-context used by expression eval. * * Also, if it's varlena, forcibly detoast it. This protects us against * storing TOAST pointers into plans that might outlive the referenced * data. (makeConst would handle detoasting anyway, but it's worth a few * extra lines here so that we can do the copy and detoast in one step.) */ if (!const_is_null) { if (resultTypLen == -1) const_val = PointerGetDatum(PG_DETOAST_DATUM_COPY(const_val)); else const_val = datumCopy(const_val, resultTypByVal, resultTypLen); } /* Release all the junk we just created */ FreeExecutorState(estate); /* * Make the constant result node. */ return (Expr *) makeConst(result_type, result_typmod, result_collation, resultTypLen, const_val, const_is_null, resultTypByVal); }