/*
* ExecIndexEvalRuntimeKeys
* Evaluate any runtime key values, and update the scankeys.
*/
void
ExecIndexEvalRuntimeKeys(ExprContext *econtext,
IndexRuntimeKeyInfo *runtimeKeys, int numRuntimeKeys)
{
int j;
MemoryContext oldContext;
/* We want to keep the key values in per-tuple memory */
oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
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 context. 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 some 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.
*
* It's also entirely possible that the result of the eval is a
* toasted value. In this case we should forcibly detoast it, to
* avoid repeat detoastings each time the value is examined by an
* index support function.
*/
scanvalue = ExecEvalExpr(key_expr,
econtext,
&isNull,
NULL);
if (isNull)
{
scan_key->sk_argument = scanvalue;
scan_key->sk_flags |= SK_ISNULL;
}
else
{
if (runtimeKeys[j].key_toastable)
scanvalue = PointerGetDatum(PG_DETOAST_DATUM(scanvalue));
scan_key->sk_argument = scanvalue;
scan_key->sk_flags &= ~SK_ISNULL;
}
}
MemoryContextSwitchTo(oldContext);
}
/*
* Executes default values for columns for which we can't map to remote
* relation columns.
*
* This allows us to support tables which have more columns on the downstream
* than on the upstream.
*/
static void
slot_fill_defaults(LogicalRepRelMapEntry *rel, EState *estate,
TupleTableSlot *slot)
{
TupleDesc desc = RelationGetDescr(rel->localrel);
int num_phys_attrs = desc->natts;
int i;
int attnum,
num_defaults = 0;
int *defmap;
ExprState **defexprs;
ExprContext *econtext;
econtext = GetPerTupleExprContext(estate);
/* We got all the data via replication, no need to evaluate anything. */
if (num_phys_attrs == rel->remoterel.natts)
return;
defmap = (int *) palloc(num_phys_attrs * sizeof(int));
defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));
for (attnum = 0; attnum < num_phys_attrs; attnum++)
{
Expr *defexpr;
if (TupleDescAttr(desc, attnum)->attisdropped)
continue;
if (rel->attrmap[attnum] >= 0)
continue;
defexpr = (Expr *) build_column_default(rel->localrel, attnum + 1);
if (defexpr != NULL)
{
/* Run the expression through planner */
defexpr = expression_planner(defexpr);
/* Initialize executable expression in copycontext */
defexprs[num_defaults] = ExecInitExpr(defexpr, NULL);
defmap[num_defaults] = attnum;
num_defaults++;
}
}
for (i = 0; i < num_defaults; i++)
slot->tts_values[defmap[i]] =
ExecEvalExpr(defexprs[i], econtext, &slot->tts_isnull[defmap[i]]);
}
/*
* Evaluate arguments for a function.
*/
static void
ExecEvalFuncArgs(FunctionCallInfo fcinfo,
List *argList,
ExprContext *econtext)
{
int i;
ListCell *arg;
i = 0;
foreach(arg, argList)
{
ExprState *argstate = (ExprState *) lfirst(arg);
fcinfo->arg[i] = ExecEvalExpr(argstate,
econtext,
&fcinfo->argnull[i]);
i++;
}
/*
* Check for assert violations and error out, if any.
*/
static void
CheckForAssertViolations(AssertOpState* node, TupleTableSlot* slot)
{
AssertOp* plannode = (AssertOp*) node->ps.plan;
ExprContext* econtext = node->ps.ps_ExprContext;
ResetExprContext(econtext);
List* predicates = node->ps.qual;
/* Arrange for econtext's scan tuple to be the tuple under test */
econtext->ecxt_outertuple = slot;
/*
* Run in short-lived per-tuple context while computing expressions.
*/
MemoryContext oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
StringInfoData errorString;
initStringInfo(&errorString);
ListCell *l = NULL;
Assert(list_length(predicates) == list_length(plannode->errmessage));
int violationCount = 0;
int listIndex = 0;
foreach(l, predicates)
{
ExprState *clause = (ExprState *) lfirst(l);
bool isNull = false;
Datum expr_value = ExecEvalExpr(clause, econtext, &isNull, NULL);
if (!isNull && !DatumGetBool(expr_value))
{
Value *valErrorMessage = (Value*) list_nth(plannode->errmessage,
listIndex);
Assert(NULL != valErrorMessage && IsA(valErrorMessage, String) &&
0 < strlen(strVal(valErrorMessage)));
appendStringInfo(&errorString, "%s\n", strVal(valErrorMessage));
violationCount++;
}
listIndex++;
}
/*
* ExecIndexEvalArrayKeys
* Evaluate any array key values, and set up to iterate through arrays.
*
* Returns TRUE if there are array elements to consider; FALSE means there
* is at least one null or empty array, so no match is possible. On TRUE
* result, the scankeys are initialized with the first elements of the arrays.
*/
bool
ExecIndexEvalArrayKeys(ExprContext *econtext,
IndexArrayKeyInfo *arrayKeys, int numArrayKeys)
{
bool result = true;
int j;
MemoryContext oldContext;
/* We want to keep the arrays in per-tuple memory */
oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
for (j = 0; j < numArrayKeys; j++)
{
ScanKey scan_key = arrayKeys[j].scan_key;
ExprState *array_expr = arrayKeys[j].array_expr;
Datum arraydatum;
bool isNull;
ArrayType *arrayval;
int16 elmlen;
bool elmbyval;
char elmalign;
int num_elems;
Datum *elem_values;
bool *elem_nulls;
/*
* Compute and deconstruct the array expression. (Notes in
* ExecIndexEvalRuntimeKeys() apply here too.)
*/
arraydatum = ExecEvalExpr(array_expr,
econtext,
&isNull,
NULL);
if (isNull)
{
result = false;
break; /* no point in evaluating more */
}
arrayval = DatumGetArrayTypeP(arraydatum);
/* We could cache this data, but not clear it's worth it */
get_typlenbyvalalign(ARR_ELEMTYPE(arrayval),
&elmlen, &elmbyval, &elmalign);
deconstruct_array(arrayval,
ARR_ELEMTYPE(arrayval),
elmlen, elmbyval, elmalign,
&elem_values, &elem_nulls, &num_elems);
if (num_elems <= 0)
{
result = false;
break; /* no point in evaluating more */
}
/*
* Note: we expect the previous array data, if any, to be
* automatically freed by resetting the per-tuple context; hence no
* pfree's here.
*/
arrayKeys[j].elem_values = elem_values;
arrayKeys[j].elem_nulls = elem_nulls;
arrayKeys[j].num_elems = num_elems;
scan_key->sk_argument = elem_values[0];
if (elem_nulls[0])
scan_key->sk_flags |= SK_ISNULL;
else
scan_key->sk_flags &= ~SK_ISNULL;
arrayKeys[j].next_elem = 1;
}
MemoryContextSwitchTo(oldContext);
return result;
}
/* ----------------------------------------------------------------
* ValuesNext
*
* This is a workhorse for ExecValuesScan
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ValuesNext(ValuesScanState *node)
{
TupleTableSlot *slot;
EState *estate;
ExprContext *econtext;
ScanDirection direction;
List *exprlist;
/*
* get information from the estate and scan state
*/
estate = node->ss.ps.state;
direction = estate->es_direction;
slot = node->ss.ss_ScanTupleSlot;
econtext = node->rowcontext;
/*
* Get the next tuple. Return NULL if no more tuples.
*/
if (ScanDirectionIsForward(direction))
{
if (node->curr_idx < node->array_len)
node->curr_idx++;
if (node->curr_idx < node->array_len)
exprlist = node->exprlists[node->curr_idx];
else
exprlist = NIL;
}
else
{
if (node->curr_idx >= 0)
node->curr_idx--;
if (node->curr_idx >= 0)
exprlist = node->exprlists[node->curr_idx];
else
exprlist = NIL;
}
/*
* Always clear the result slot; this is appropriate if we are at the end
* of the data, and if we're not, we still need it as the first step of
* the store-virtual-tuple protocol. It seems wise to clear the slot
* before we reset the context it might have pointers into.
*/
ExecClearTuple(slot);
if (exprlist)
{
MemoryContext oldContext;
List *exprstatelist;
Datum *values;
bool *isnull;
ListCell *lc;
int resind;
/*
* Get rid of any prior cycle's leftovers. We use ReScanExprContext
* not just ResetExprContext because we want any registered shutdown
* callbacks to be called.
*/
ReScanExprContext(econtext);
/*
* Build the expression eval state in the econtext's per-tuple memory.
* This is a tad unusual, but we want to delete the eval state again
* when we move to the next row, to avoid growth of memory
* requirements over a long values list.
*/
oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
/*
* Pass NULL, not my plan node, because we don't want anything in this
* transient state linking into permanent state. The only possibility
* is a SubPlan, and there shouldn't be any (any subselects in the
* VALUES list should be InitPlans).
*/
exprstatelist = (List *) ExecInitExpr((Expr *) exprlist, NULL);
/* parser should have checked all sublists are the same length */
Assert(list_length(exprstatelist) == slot->tts_tupleDescriptor->natts);
/*
* Compute the expressions and build a virtual result tuple. We
* already did ExecClearTuple(slot).
*/
values = slot->tts_values;
isnull = slot->tts_isnull;
resind = 0;
foreach(lc, exprstatelist)
{
ExprState *estate = (ExprState *) lfirst(lc);
values[resind] = ExecEvalExpr(estate,
econtext,
&isnull[resind],
NULL);
resind++;
}
MemoryContextSwitchTo(oldContext);
/*
* And return the virtual tuple.
*/
ExecStoreVirtualTuple(slot);
}
/*
* Repeatly output each tuple received from the outer plan with some
* defined number of times. The number of times to output a tuple is
* determined by the value of a given column in the received tuple.
*
* Note that the Repeat node also have the functionality to evaluate
* the GroupingFunc.
*/
TupleTableSlot *
ExecRepeat(RepeatState *repeatstate)
{
TupleTableSlot *outerslot;
ExprContext *econtext = repeatstate->ps.ps_ExprContext;
Repeat *node = (Repeat *)repeatstate->ps.plan;
if (repeatstate->repeat_done)
return NULL;
/*
* If the previous tuple still needs to be outputted,
* output it here.
*/
if (repeatstate->slot != NULL)
{
if (repeatstate->repeat_count > 0)
{
/* Output the previous tuple */
econtext->ecxt_outertuple = repeatstate->slot;
econtext->ecxt_scantuple = repeatstate->slot;
do
{
econtext->group_id = repeatstate->repeat_count - 1;
econtext->grouping = node->grouping;
repeatstate->repeat_count--;
/* Check the qual until we find one output tuple. */
if (ExecQual(repeatstate->ps.qual, econtext, false))
{
Gpmon_M_Incr_Rows_Out(GpmonPktFromRepeatState(repeatstate));
CheckSendPlanStateGpmonPkt(&repeatstate->ps);
return ExecProject(repeatstate->ps.ps_ProjInfo, NULL);
}
} while (repeatstate->repeat_count > 0);
}
else
repeatstate->slot = NULL;
}
ResetExprContext(econtext);
while (!repeatstate->repeat_done)
{
MemoryContext oldcxt;
bool isNull = false;
outerslot = ExecProcNode(outerPlanState(repeatstate));
if (TupIsNull(outerslot))
{
repeatstate->repeat_done = true;
return NULL;
}
econtext->ecxt_outertuple = outerslot;
econtext->ecxt_scantuple = outerslot;
/* Compute the number of times to output this tuple. */
oldcxt = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
repeatstate->repeat_count =
DatumGetInt32(ExecEvalExpr(repeatstate->expr_state, econtext,
&isNull, NULL));
Assert(!isNull);
MemoryContextSwitchTo(oldcxt);
if (repeatstate->repeat_count == 0)
continue;
if (repeatstate->repeat_count > 1)
repeatstate->slot = outerslot;
do
{
econtext->group_id = repeatstate->repeat_count - 1;
econtext->grouping = node->grouping;
repeatstate->repeat_count--;
/* Check the qual until we find one output tuple. */
if (ExecQual(repeatstate->ps.qual, econtext, false))
{
Gpmon_M_Incr_Rows_Out(GpmonPktFromRepeatState(repeatstate));
CheckSendPlanStateGpmonPkt(&repeatstate->ps);
return ExecProject(repeatstate->ps.ps_ProjInfo, NULL);
}
} while (repeatstate->repeat_count > 0);
}
return NULL;
}
TupleCheckStatus
FilterInit(Filter *filter, TupleDesc desc, Oid collation)
{
int i;
ParsedFunction func;
HeapTuple ftup;
HeapTuple ltup;
Form_pg_proc pp;
Form_pg_language lp;
TupleCheckStatus status = NEED_COERCION_CHECK;
if (filter->funcstr == NULL)
return NO_COERCION;
/* parse filter function */
func = ParseFunction(filter->funcstr, true);
filter->funcid = func.oid;
filter->nargs = func.nargs;
for (i = 0; i < filter->nargs; i++)
{
/* Check for polymorphic types and internal pseudo-type argument */
if (IsPolymorphicType(func.argtypes[i]) ||
func.argtypes[i] == INTERNALOID)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("filter function does not support a polymorphic function and having a internal pseudo-type argument function: %s",
get_func_name(filter->funcid))));
filter->argtypes[i] = func.argtypes[i];
}
ftup = SearchSysCache(PROCOID, ObjectIdGetDatum(filter->funcid), 0, 0, 0);
pp = (Form_pg_proc) GETSTRUCT(ftup);
if (pp->proretset)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("filter function must not return set")));
/* Check data type of the function result value */
if (pp->prorettype == desc->tdtypeid && pp->prorettype != RECORDOID)
status = NO_COERCION;
else if (pp->prorettype == RECORDOID)
{
TupleDesc resultDesc = NULL;
/* Check for OUT parameters defining a RECORD result */
resultDesc = build_function_result_tupdesc_t(ftup);
if (resultDesc)
{
if (tupledesc_match(desc, resultDesc))
status = NO_COERCION;
FreeTupleDesc(resultDesc);
}
}
else if (get_typtype(pp->prorettype) != TYPTYPE_COMPOSITE)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("function return data type and target table data type do not match")));
/* Get default values */
#if PG_VERSION_NUM >= 80400
filter->fn_ndargs = pp->pronargdefaults;
if (filter->fn_ndargs > 0)
{
Datum proargdefaults;
bool isnull;
char *str;
List *defaults;
ListCell *l;
filter->defaultValues = palloc(sizeof(Datum) * filter->fn_ndargs);
filter->defaultIsnull = palloc(sizeof(bool) * filter->fn_ndargs);
proargdefaults = SysCacheGetAttr(PROCOID, ftup,
Anum_pg_proc_proargdefaults,
&isnull);
Assert(!isnull);
str = TextDatumGetCString(proargdefaults);
defaults = (List *) stringToNode(str);
Assert(IsA(defaults, List));
pfree(str);
filter->econtext = CreateStandaloneExprContext();
i = 0;
foreach(l, defaults)
{
Expr *expr = (Expr *) lfirst(l);
ExprState *argstate;
ExprDoneCond thisArgIsDone;
argstate = ExecInitExpr(expr, NULL);
filter->defaultValues[i] = ExecEvalExpr(argstate,
filter->econtext,
&filter->defaultIsnull[i],
&thisArgIsDone);
if (thisArgIsDone != ExprSingleResult)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("functions and operators can take at most one set argument")));
i++;
}
static void
FunctionParserInit(FunctionParser *self, Checker *checker, const char *infile, TupleDesc desc, bool multi_process, Oid collation)
{
int i;
ParsedFunction function;
int nargs;
Oid funcid;
HeapTuple ftup;
Form_pg_proc pp;
bool tupledesc_matched = false;
if (pg_strcasecmp(infile, "stdin") == 0)
ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot load from STDIN in the case of \"TYPE = FUNCTION\"")));
if (checker->encoding != -1)
ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("does not support parameter \"ENCODING\" in \"TYPE = FUNCTION\"")));
function = ParseFunction(infile, false);
funcid = function.oid;
fmgr_info(funcid, &self->flinfo);
if (!self->flinfo.fn_retset)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("function must return set")));
ftup = SearchSysCache(PROCOID, ObjectIdGetDatum(funcid), 0, 0, 0);
pp = (Form_pg_proc) GETSTRUCT(ftup);
/* Check data type of the function result value */
if (pp->prorettype == desc->tdtypeid && desc->tdtypeid != RECORDOID)
tupledesc_matched = true;
else if (pp->prorettype == RECORDOID)
{
TupleDesc resultDesc = NULL;
/* Check for OUT parameters defining a RECORD result */
resultDesc = build_function_result_tupdesc_t(ftup);
if (resultDesc)
{
tupledesc_match(desc, resultDesc);
tupledesc_matched = true;
FreeTupleDesc(resultDesc);
}
}
else if (get_typtype(pp->prorettype) != TYPTYPE_COMPOSITE)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("function return data type and target table data type do not match")));
if (tupledesc_matched && checker->tchecker)
checker->tchecker->status = NO_COERCION;
/*
* assign arguments
*/
nargs = function.nargs;
for (i = 0;
#if PG_VERSION_NUM >= 80400
i < nargs - function.nvargs;
#else
i < nargs;
#endif
++i)
{
if (function.args[i] == NULL)
{
if (self->flinfo.fn_strict)
ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("function is strict, but argument %d is NULL", i)));
self->fcinfo.argnull[i] = true;
}
else
{
Oid typinput;
Oid typioparam;
getTypeInputInfo(pp->proargtypes.values[i], &typinput, &typioparam);
self->fcinfo.arg[i] = OidInputFunctionCall(typinput,
(char *) function.args[i], typioparam, -1);
self->fcinfo.argnull[i] = false;
pfree(function.args[i]);
}
}
/*
* assign variadic arguments
*/
#if PG_VERSION_NUM >= 80400
if (function.nvargs > 0)
{
int nfixedarg;
Oid func;
Oid element_type;
int16 elmlen;
bool elmbyval;
char elmalign;
char elmdelim;
Oid elmioparam;
Datum *elems;
bool *nulls;
int dims[1];
int lbs[1];
ArrayType *arry;
nfixedarg = i;
element_type = pp->provariadic;
/*
* Get info about element type, including its input conversion proc
*/
get_type_io_data(element_type, IOFunc_input,
&elmlen, &elmbyval, &elmalign, &elmdelim,
&elmioparam, &func);
elems = (Datum *) palloc(function.nvargs * sizeof(Datum));
nulls = (bool *) palloc0(function.nvargs * sizeof(bool));
for (i = 0; i < function.nvargs; i++)
{
if (function.args[nfixedarg + i] == NULL)
nulls[i] = true;
else
{
elems[i] = OidInputFunctionCall(func,
(char *) function.args[nfixedarg + i], elmioparam, -1);
pfree(function.args[nfixedarg + i]);
}
}
dims[0] = function.nvargs;
lbs[0] = 1;
arry = construct_md_array(elems, nulls, 1, dims, lbs, element_type,
elmlen, elmbyval, elmalign);
self->fcinfo.arg[nfixedarg] = PointerGetDatum(arry);
}
/*
* assign default arguments
*/
if (function.ndargs > 0)
{
Datum proargdefaults;
bool isnull;
char *str;
List *defaults;
int ndelete;
ListCell *l;
/* shouldn't happen, FuncnameGetCandidates messed up */
if (function.ndargs > pp->pronargdefaults)
elog(ERROR, "not enough default arguments");
proargdefaults = SysCacheGetAttr(PROCOID, ftup,
Anum_pg_proc_proargdefaults,
&isnull);
Assert(!isnull);
str = TextDatumGetCString(proargdefaults);
defaults = (List *) stringToNode(str);
Assert(IsA(defaults, List));
pfree(str);
/* Delete any unused defaults from the returned list */
ndelete = list_length(defaults) - function.ndargs;
while (ndelete-- > 0)
defaults = list_delete_first(defaults);
self->arg_econtext = CreateStandaloneExprContext();
foreach(l, defaults)
{
Expr *expr = (Expr *) lfirst(l);
ExprState *argstate;
ExprDoneCond thisArgIsDone;
/* probably shouldn't happen ... */
if (nargs >= FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
errmsg("cannot pass more than %d arguments to a function", FUNC_MAX_ARGS)));
argstate = ExecInitExpr(expr, NULL);
self->fcinfo.arg[nargs] = ExecEvalExpr(argstate,
self->arg_econtext,
&self->fcinfo.argnull[nargs],
&thisArgIsDone);
if (thisArgIsDone != ExprSingleResult)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("functions and operators can take at most one set argument")));
nargs++;
}
/* ----------------------------------------------------------------
* ValuesNext
*
* This is a workhorse for ExecValuesScan
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ValuesNext(ValuesScanState *node)
{
TupleTableSlot *slot;
EState *estate;
ExprContext *econtext;
ScanDirection direction;
List *exprlist;
/*
* get information from the estate and scan state
*/
estate = node->ss.ps.state;
direction = estate->es_direction;
slot = node->ss.ss_ScanTupleSlot;
econtext = node->rowcontext;
/*
* Get the next tuple. Return NULL if no more tuples.
*/
if (ScanDirectionIsForward(direction))
{
if (node->curr_idx < node->array_len)
node->curr_idx++;
if (node->curr_idx < node->array_len)
exprlist = node->exprlists[node->curr_idx];
else
exprlist = NIL;
}
else
{
if (node->curr_idx >= 0)
node->curr_idx--;
if (node->curr_idx >= 0)
exprlist = node->exprlists[node->curr_idx];
else
exprlist = NIL;
}
/*
* Always clear the result slot; this is appropriate if we are at the end
* of the data, and if we're not, we still need it as the first step of
* the store-virtual-tuple protocol. It seems wise to clear the slot
* before we reset the context it might have pointers into.
*/
ExecClearTuple(slot);
if (exprlist)
{
MemoryContext oldContext;
List *oldsubplans;
List *exprstatelist;
Datum *values;
bool *isnull;
ListCell *lc;
int resind;
int saved_jit_flags;
/*
* Get rid of any prior cycle's leftovers. We use ReScanExprContext
* not just ResetExprContext because we want any registered shutdown
* callbacks to be called.
*/
ReScanExprContext(econtext);
/*
* Build the expression eval state in the econtext's per-tuple memory.
* This is a tad unusual, but we want to delete the eval state again
* when we move to the next row, to avoid growth of memory
* requirements over a long values list.
*/
oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
/*
* The expressions might contain SubPlans (this is currently only
* possible if there's a sub-select containing a LATERAL reference,
* otherwise sub-selects in a VALUES list should be InitPlans). Those
* subplans will want to hook themselves into our subPlan list, which
* would result in a corrupted list after we delete the eval state. We
* can work around this by saving and restoring the subPlan list.
* (There's no need for the functionality that would be enabled by
* having the list entries, since the SubPlans aren't going to be
* re-executed anyway.)
*/
oldsubplans = node->ss.ps.subPlan;
node->ss.ps.subPlan = NIL;
/*
* As the expressions are only ever used once, disable JIT for them.
* This is worthwhile because it's common to insert significant
* amounts of data via VALUES().
*/
saved_jit_flags = econtext->ecxt_estate->es_jit_flags;
econtext->ecxt_estate->es_jit_flags = PGJIT_NONE;
exprstatelist = ExecInitExprList(exprlist, &node->ss.ps);
econtext->ecxt_estate->es_jit_flags = saved_jit_flags;
node->ss.ps.subPlan = oldsubplans;
/* parser should have checked all sublists are the same length */
Assert(list_length(exprstatelist) == slot->tts_tupleDescriptor->natts);
/*
* Compute the expressions and build a virtual result tuple. We
* already did ExecClearTuple(slot).
*/
values = slot->tts_values;
isnull = slot->tts_isnull;
resind = 0;
foreach(lc, exprstatelist)
{
ExprState *estate = (ExprState *) lfirst(lc);
Form_pg_attribute attr = TupleDescAttr(slot->tts_tupleDescriptor,
resind);
values[resind] = ExecEvalExpr(estate,
econtext,
&isnull[resind]);
/*
* We must force any R/W expanded datums to read-only state, in
* case they are multiply referenced in the plan node's output
* expressions, or in case we skip the output projection and the
* output column is multiply referenced in higher plan nodes.
*/
values[resind] = MakeExpandedObjectReadOnly(values[resind],
isnull[resind],
attr->attlen);
resind++;
}
MemoryContextSwitchTo(oldContext);
/*
* And return the virtual tuple.
*/
ExecStoreVirtualTuple(slot);
}
/*
* ExecMakeTableFunctionResult
*
* Evaluate a table function, producing a materialized result in a Tuplestore
* object.
*
* This is used by nodeFunctionscan.c.
*/
Tuplestorestate *
ExecMakeTableFunctionResult(SetExprState *setexpr,
ExprContext *econtext,
MemoryContext argContext,
TupleDesc expectedDesc,
bool randomAccess)
{
Tuplestorestate *tupstore = NULL;
TupleDesc tupdesc = NULL;
Oid funcrettype;
bool returnsTuple;
bool returnsSet = false;
FunctionCallInfoData fcinfo;
PgStat_FunctionCallUsage fcusage;
ReturnSetInfo rsinfo;
HeapTupleData tmptup;
MemoryContext callerContext;
MemoryContext oldcontext;
bool first_time = true;
callerContext = CurrentMemoryContext;
funcrettype = exprType((Node *) setexpr->expr);
returnsTuple = type_is_rowtype(funcrettype);
/*
* Prepare a resultinfo node for communication. We always do this even if
* not expecting a set result, so that we can pass expectedDesc. In the
* generic-expression case, the expression doesn't actually get to see the
* resultinfo, but set it up anyway because we use some of the fields as
* our own state variables.
*/
rsinfo.type = T_ReturnSetInfo;
rsinfo.econtext = econtext;
rsinfo.expectedDesc = expectedDesc;
rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize | SFRM_Materialize_Preferred);
if (randomAccess)
rsinfo.allowedModes |= (int) SFRM_Materialize_Random;
rsinfo.returnMode = SFRM_ValuePerCall;
/* isDone is filled below */
rsinfo.setResult = NULL;
rsinfo.setDesc = NULL;
/*
* Normally the passed expression tree will be a SetExprState, since the
* grammar only allows a function call at the top level of a table
* function reference. However, if the function doesn't return set then
* the planner might have replaced the function call via constant-folding
* or inlining. So if we see any other kind of expression node, execute
* it via the general ExecEvalExpr() code; the only difference is that we
* don't get a chance to pass a special ReturnSetInfo to any functions
* buried in the expression.
*/
if (!setexpr->elidedFuncState)
{
/*
* This path is similar to ExecMakeFunctionResultSet.
*/
returnsSet = setexpr->funcReturnsSet;
InitFunctionCallInfoData(fcinfo, &(setexpr->func),
list_length(setexpr->args),
setexpr->fcinfo_data.fncollation,
NULL, (Node *) &rsinfo);
/*
* Evaluate the function's argument list.
*
* We can't do this in the per-tuple context: the argument values
* would disappear when we reset that context in the inner loop. And
* the caller's CurrentMemoryContext is typically a query-lifespan
* context, so we don't want to leak memory there. We require the
* caller to pass a separate memory context that can be used for this,
* and can be reset each time through to avoid bloat.
*/
MemoryContextReset(argContext);
oldcontext = MemoryContextSwitchTo(argContext);
ExecEvalFuncArgs(&fcinfo, setexpr->args, econtext);
MemoryContextSwitchTo(oldcontext);
/*
* If function is strict, and there are any NULL arguments, skip
* calling the function and act like it returned NULL (or an empty
* set, in the returns-set case).
*/
if (setexpr->func.fn_strict)
{
int i;
for (i = 0; i < fcinfo.nargs; i++)
{
if (fcinfo.argnull[i])
goto no_function_result;
}
}
}
else
{
/* Treat setexpr as a generic expression */
InitFunctionCallInfoData(fcinfo, NULL, 0, InvalidOid, NULL, NULL);
}
/*
* Switch to short-lived context for calling the function or expression.
*/
MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
/*
* Loop to handle the ValuePerCall protocol (which is also the same
* behavior needed in the generic ExecEvalExpr path).
*/
for (;;)
{
Datum result;
CHECK_FOR_INTERRUPTS();
/*
* reset per-tuple memory context before each call of the function or
* expression. This cleans up any local memory the function may leak
* when called.
*/
ResetExprContext(econtext);
/* Call the function or expression one time */
if (!setexpr->elidedFuncState)
{
pgstat_init_function_usage(&fcinfo, &fcusage);
fcinfo.isnull = false;
rsinfo.isDone = ExprSingleResult;
result = FunctionCallInvoke(&fcinfo);
pgstat_end_function_usage(&fcusage,
rsinfo.isDone != ExprMultipleResult);
}
else
{
result =
ExecEvalExpr(setexpr->elidedFuncState, econtext, &fcinfo.isnull);
rsinfo.isDone = ExprSingleResult;
}
/* Which protocol does function want to use? */
if (rsinfo.returnMode == SFRM_ValuePerCall)
{
/*
* Check for end of result set.
*/
if (rsinfo.isDone == ExprEndResult)
break;
/*
* If first time through, build tuplestore for result. For a
* scalar function result type, also make a suitable tupdesc.
*/
if (first_time)
{
oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
rsinfo.setResult = tupstore;
if (!returnsTuple)
{
tupdesc = CreateTemplateTupleDesc(1, false);
TupleDescInitEntry(tupdesc,
(AttrNumber) 1,
"column",
funcrettype,
-1,
0);
rsinfo.setDesc = tupdesc;
}
MemoryContextSwitchTo(oldcontext);
}
/*
* Store current resultset item.
*/
if (returnsTuple)
{
if (!fcinfo.isnull)
{
HeapTupleHeader td = DatumGetHeapTupleHeader(result);
if (tupdesc == NULL)
{
/*
* This is the first non-NULL result from the
* function. Use the type info embedded in the
* rowtype Datum to look up the needed tupdesc. Make
* a copy for the query.
*/
oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
tupdesc = lookup_rowtype_tupdesc_copy(HeapTupleHeaderGetTypeId(td),
HeapTupleHeaderGetTypMod(td));
rsinfo.setDesc = tupdesc;
MemoryContextSwitchTo(oldcontext);
}
else
{
/*
* Verify all later returned rows have same subtype;
* necessary in case the type is RECORD.
*/
if (HeapTupleHeaderGetTypeId(td) != tupdesc->tdtypeid ||
HeapTupleHeaderGetTypMod(td) != tupdesc->tdtypmod)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("rows returned by function are not all of the same row type")));
}
/*
* tuplestore_puttuple needs a HeapTuple not a bare
* HeapTupleHeader, but it doesn't need all the fields.
*/
tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
tmptup.t_data = td;
tuplestore_puttuple(tupstore, &tmptup);
}
else
{
/*
* NULL result from a tuple-returning function; expand it
* to a row of all nulls. We rely on the expectedDesc to
* form such rows. (Note: this would be problematic if
* tuplestore_putvalues saved the tdtypeid/tdtypmod from
* the provided descriptor, since that might not match
* what we get from the function itself. But it doesn't.)
*/
int natts = expectedDesc->natts;
bool *nullflags;
nullflags = (bool *) palloc(natts * sizeof(bool));
memset(nullflags, true, natts * sizeof(bool));
tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
}
}
else
{
/* Scalar-type case: just store the function result */
tuplestore_putvalues(tupstore, tupdesc, &result, &fcinfo.isnull);
}
/*
* Are we done?
*/
if (rsinfo.isDone != ExprMultipleResult)
break;
}
else if (rsinfo.returnMode == SFRM_Materialize)
{
/* check we're on the same page as the function author */
if (!first_time || rsinfo.isDone != ExprSingleResult)
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
errmsg("table-function protocol for materialize mode was not followed")));
/* Done evaluating the set result */
break;
}
else
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
errmsg("unrecognized table-function returnMode: %d",
(int) rsinfo.returnMode)));
first_time = false;
}
no_function_result:
/*
* If we got nothing from the function (ie, an empty-set or NULL result),
* we have to create the tuplestore to return, and if it's a
* non-set-returning function then insert a single all-nulls row. As
* above, we depend on the expectedDesc to manufacture the dummy row.
*/
if (rsinfo.setResult == NULL)
{
MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
rsinfo.setResult = tupstore;
if (!returnsSet)
{
int natts = expectedDesc->natts;
bool *nullflags;
MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
nullflags = (bool *) palloc(natts * sizeof(bool));
memset(nullflags, true, natts * sizeof(bool));
tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
}
}
/*
* If function provided a tupdesc, cross-check it. We only really need to
* do this for functions returning RECORD, but might as well do it always.
*/
if (rsinfo.setDesc)
{
tupledesc_match(expectedDesc, rsinfo.setDesc);
/*
* If it is a dynamically-allocated TupleDesc, free it: it is
* typically allocated in a per-query context, so we must avoid
* leaking it across multiple usages.
*/
if (rsinfo.setDesc->tdrefcount == -1)
FreeTupleDesc(rsinfo.setDesc);
}
MemoryContextSwitchTo(callerContext);
/* All done, pass back the tuplestore */
return rsinfo.setResult;
}
/*
* GetStreamScanPlan
*/
ForeignScan *
GetStreamScanPlan(PlannerInfo *root, RelOptInfo *baserel,
Oid relid, ForeignPath *best_path, List *tlist, List *scan_clauses, Plan *outer_plan)
{
StreamFdwInfo *sinfo = (StreamFdwInfo *) baserel->fdw_private;
List *physical_tlist = build_physical_tlist(root, baserel);
RangeTblEntry *rte = NULL;
int i;
TableSampleClause *sample;
Value *sample_cutoff = NULL;
/* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
scan_clauses = extract_actual_clauses(scan_clauses, false);
for (i = 1; i <= root->simple_rel_array_size; i++)
{
rte = root->simple_rte_array[i];
if (rte && rte->relid == relid)
break;
}
if (!rte || rte->relid != relid)
elog(ERROR, "stream RTE missing");
sample = rte->tablesample;
if (sample)
{
double dcutoff;
Datum d;
ExprContext *econtext;
bool isnull;
Node *node;
Expr *expr;
ExprState *estate;
ParseState *ps = make_parsestate(NULL);
float4 percent;
if (sample->tsmhandler != BERNOULLI_OID)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("tablesample method %s is not supported by streams", get_func_name(sample->tsmhandler)),
errhint("Only bernoulli tablesample method can be used with streams.")));
if (sample->repeatable)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("streams don't support the REPEATABLE clause for tablesample")));
econtext = CreateStandaloneExprContext();
ps = make_parsestate(NULL);
node = (Node *) linitial(sample->args);
node = transformExpr(ps, node, EXPR_KIND_OTHER);
expr = expression_planner((Expr *) node);
estate = ExecInitExpr(expr, NULL);
d = ExecEvalExpr(estate, econtext, &isnull, NULL);
free_parsestate(ps);
FreeExprContext(econtext, false);
percent = DatumGetFloat4(d);
if (percent < 0 || percent > 100 || isnan(percent))
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLESAMPLE_ARGUMENT),
errmsg("sample percentage must be between 0 and 100")));
dcutoff = rint(((double) RAND_MAX + 1) * percent / 100);
sample_cutoff = makeInteger((int) dcutoff);
}
return make_foreignscan(tlist, scan_clauses, baserel->relid,
NIL, list_make3(sinfo->colnames, physical_tlist, sample_cutoff), NIL, NIL, outer_plan);
}
/*
* Initialize the TABLESAMPLE Descriptor and the TABLESAMPLE Method.
*/
TableSampleDesc *
tablesample_init(SampleScanState *scanstate, TableSampleClause *tablesample)
{
FunctionCallInfoData fcinfo;
int i;
List *args = tablesample->args;
ListCell *arg;
ExprContext *econtext = scanstate->ss.ps.ps_ExprContext;
TableSampleDesc *tsdesc = (TableSampleDesc *) palloc0(sizeof(TableSampleDesc));
/* Load functions */
fmgr_info(tablesample->tsminit, &(tsdesc->tsminit));
fmgr_info(tablesample->tsmnextblock, &(tsdesc->tsmnextblock));
fmgr_info(tablesample->tsmnexttuple, &(tsdesc->tsmnexttuple));
if (OidIsValid(tablesample->tsmexaminetuple))
fmgr_info(tablesample->tsmexaminetuple, &(tsdesc->tsmexaminetuple));
else
tsdesc->tsmexaminetuple.fn_oid = InvalidOid;
fmgr_info(tablesample->tsmreset, &(tsdesc->tsmreset));
fmgr_info(tablesample->tsmend, &(tsdesc->tsmend));
InitFunctionCallInfoData(fcinfo, &tsdesc->tsminit,
list_length(args) + 2,
InvalidOid, NULL, NULL);
tsdesc->tupDesc = scanstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
tsdesc->heapScan = scanstate->ss.ss_currentScanDesc;
/* First argument for init function is always TableSampleDesc */
fcinfo.arg[0] = PointerGetDatum(tsdesc);
fcinfo.argnull[0] = false;
/*
* Second arg for init function is always REPEATABLE
* When tablesample->repeatable is NULL then REPEATABLE clause was not
* specified.
* When specified, the expression cannot evaluate to NULL.
*/
if (tablesample->repeatable)
{
ExprState *argstate = ExecInitExpr((Expr *) tablesample->repeatable,
(PlanState *) scanstate);
fcinfo.arg[1] = ExecEvalExpr(argstate, econtext,
&fcinfo.argnull[1], NULL);
if (fcinfo.argnull[1])
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("REPEATABLE clause must be NOT NULL numeric value")));
}
else
{
fcinfo.arg[1] = UInt32GetDatum(random());
fcinfo.argnull[1] = false;
}
/* Rest of the arguments come from user. */
i = 2;
foreach(arg, args)
{
Expr *argexpr = (Expr *) lfirst(arg);
ExprState *argstate = ExecInitExpr(argexpr, (PlanState *) scanstate);
if (argstate == NULL)
{
fcinfo.argnull[i] = true;
fcinfo.arg[i] = (Datum) 0;;
}
fcinfo.arg[i] = ExecEvalExpr(argstate, econtext,
&fcinfo.argnull[i], NULL);
i++;
}