/*
* 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);
}
