50 #include "utils/fmgroids.h"
119 bool *haveNull,
bool *forceTrue);
122 bool *haveNull,
bool *forceFalse);
125 Oid result_type,
int32 result_typmod,
126 Oid result_collid,
Oid input_collid,
List **args_p,
127 bool funcvariadic,
bool process_args,
bool allow_non_const,
249 elog(
ERROR,
"WindowFunc contains out-of-range winref %u",
297 if (expr->funcretset)
405 foreach(lc, ctor->
args)
429 if (cnst->constisnull)
681 return (func_id != F_NEXTVAL &&
738 context.max_hazard = PROPARALLEL_SAFE;
739 context.max_interesting = PROPARALLEL_UNSAFE;
765 if (
root->glob->maxParallelHazard == PROPARALLEL_SAFE &&
766 root->glob->paramExecTypes ==
NIL)
769 context.max_hazard = PROPARALLEL_SAFE;
770 context.max_interesting = PROPARALLEL_RESTRICTED;
778 for (proot =
root; proot != NULL; proot = proot->parent_root)
798 case PROPARALLEL_SAFE:
801 case PROPARALLEL_RESTRICTED:
804 context->max_hazard = proparallel;
806 if (
context->max_interesting == proparallel)
809 case PROPARALLEL_UNSAFE:
810 context->max_hazard = proparallel;
814 elog(
ERROR,
"unrecognized proparallel value \"%c\"", proparallel);
905 List *save_safe_param_ids;
910 save_safe_param_ids =
context->safe_param_ids;
916 context->safe_param_ids = save_safe_param_ids;
959 context->max_hazard = PROPARALLEL_UNSAFE;
1186 #define CCDN_CASETESTEXPR_OK 0x0001
1206 int save_flags = *flags;
1221 *flags = save_flags;
1236 save_flags = *flags;
1240 *flags = save_flags;
1288 case T_NamedArgExpr:
1293 case T_CaseTestExpr:
1295 case T_SQLValueFunction:
1298 case T_NextValueExpr:
1309 case T_DistinctExpr:
1311 case T_ScalarArrayOpExpr:
1313 case T_ArrayCoerceExpr:
1325 case T_SubscriptingRef:
1345 case T_RowCompareExpr:
1358 larg, rcexpr->
largs,
1359 rarg, rcexpr->
rargs)
1401 case T_CurrentOfExpr:
1487 foreach(l, (
List *) node)
1546 foreach(l, expr->
args)
1740 foreach(l, (
List *) node)
1804 foreach(l, expr->
args)
1939 foreach(l, (
List *) node)
2035 if (expr->
useOr && falseOK)
2040 if (rightop &&
IsA(rightop,
Const))
2042 Datum arraydatum = ((
Const *) rightop)->constvalue;
2043 bool arrayisnull = ((
Const *) rightop)->constisnull;
2058 if (arrayexpr->
elements !=
NIL && !arrayexpr->multidims)
2155 elog(
ERROR,
"cannot commute non-binary-operator clause");
2160 elog(
ERROR,
"could not find commutator for operator %u",
2166 clause->
opno = opoid;
2187 Oid expectedtype,
int32 expectedtypmod,
2188 Oid expectedcollation)
2194 if (rowtypeid == RECORDOID)
2197 if (fieldnum <= 0 || fieldnum > tupdesc->
natts)
2203 if (attr->attisdropped ||
2204 attr->atttypid != expectedtype ||
2205 attr->atttypmod != expectedtypmod ||
2206 attr->attcollation != expectedcollation)
2269 #define MIN_ARRAY_SIZE_FOR_HASHED_SAOP 9
2305 if (arrayarg &&
IsA(arrayarg,
Const) &&
2306 !((
Const *) arrayarg)->constisnull)
2311 lefthashfunc == righthashfunc)
2313 Datum arrdatum = ((
Const *) arrayarg)->constvalue;
2327 saop->hashfuncid = lefthashfunc;
2343 lefthashfunc == righthashfunc)
2345 Datum arrdatum = ((
Const *) arrayarg)->constvalue;
2359 saop->hashfuncid = lefthashfunc;
2417 #define ece_generic_processing(node) \
2418 expression_tree_mutator((Node *) (node), eval_const_expressions_mutator, \
2426 #define ece_all_arguments_const(node) \
2427 (!expression_tree_walker((Node *) (node), contain_non_const_walker, NULL))
2430 #define ece_evaluate_expr(node) \
2431 ((Node *) evaluate_expr((Expr *) (node), \
2432 exprType((Node *) (node)), \
2433 exprTypmod((Node *) (node)), \
2434 exprCollation((Node *) (node))))
2501 &typLen, &typByVal);
2502 if (prm->
isnull || typByVal)
2514 return (
Node *) con;
2543 elog(
ERROR,
"cache lookup failed for function %u", funcid);
2546 false, expr->wintype,
2557 aggfilter = (
Expr *)
2564 newexpr->wintype = expr->wintype;
2565 newexpr->wincollid = expr->wincollid;
2566 newexpr->inputcollid = expr->inputcollid;
2570 newexpr->winstar = expr->winstar;
2571 newexpr->winagg = expr->winagg;
2574 return (
Node *) newexpr;
2591 expr->funcresulttype,
2601 return (
Node *) simple;
2611 newexpr->funcresulttype = expr->funcresulttype;
2612 newexpr->funcretset = expr->funcretset;
2613 newexpr->funcvariadic = expr->funcvariadic;
2614 newexpr->funcformat = expr->funcformat;
2615 newexpr->funccollid = expr->funccollid;
2616 newexpr->inputcollid = expr->inputcollid;
2619 return (
Node *) newexpr;
2639 expr->opresulttype, -1,
2648 return (
Node *) simple;
2655 if (expr->
opno == BooleanEqualOperator ||
2656 expr->
opno == BooleanNotEqualOperator)
2661 return (
Node *) simple;
2671 newexpr->opfuncid = expr->opfuncid;
2672 newexpr->opresulttype = expr->opresulttype;
2673 newexpr->opretset = expr->opretset;
2674 newexpr->opcollid = expr->opcollid;
2675 newexpr->inputcollid = expr->inputcollid;
2678 return (
Node *) newexpr;
2680 case T_DistinctExpr:
2685 bool has_null_input =
false;
2686 bool all_null_input =
true;
2687 bool has_nonconst_input =
false;
2714 has_nonconst_input =
true;
2718 if (!has_nonconst_input)
2743 expr->opresulttype, -1,
2759 csimple->constvalue =
2761 return (
Node *) csimple;
2772 newexpr->opfuncid = expr->opfuncid;
2773 newexpr->opresulttype = expr->opresulttype;
2774 newexpr->opretset = expr->opretset;
2775 newexpr->opcollid = expr->opcollid;
2776 newexpr->inputcollid = expr->inputcollid;
2779 return (
Node *) newexpr;
2785 bool has_nonconst_input =
false;
2794 has_nonconst_input =
true;
2805 if (!has_nonconst_input &&
2809 return (
Node *) expr;
2811 case T_ScalarArrayOpExpr:
2828 return (
Node *) saop;
2839 bool haveNull =
false;
2840 bool forceTrue =
false;
2867 bool haveNull =
false;
2868 bool forceFalse =
false;
2914 case T_JsonValueExpr:
2921 if (formatted &&
IsA(formatted,
Const))
2927 case T_AlternativeSubPlan:
2947 relabel->resulttypmod,
2948 relabel->resultcollid,
2949 relabel->relabelformat,
2958 bool outtypisvarlena;
2977 &outfunc, &outtypisvarlena);
2979 &infunc, &intypioparam);
3023 return (
Node *) simple;
3034 newexpr->resultcollid = expr->resultcollid;
3035 newexpr->coerceformat = expr->coerceformat;
3037 return (
Node *) newexpr;
3039 case T_ArrayCoerceExpr:
3042 Node *save_case_val;
3058 save_case_val =
context->case_val;
3065 context->case_val = save_case_val;
3140 Node *save_case_val;
3143 bool const_true_cond;
3144 Node *defresult = NULL;
3152 save_case_val =
context->case_val;
3163 const_true_cond =
false;
3179 if (casecond &&
IsA(casecond,
Const))
3183 if (const_input->constisnull ||
3187 const_true_cond =
true;
3195 if (!const_true_cond)
3199 newcasewhen->
expr = (
Expr *) casecond;
3202 newargs =
lappend(newargs, newcasewhen);
3211 defresult = caseresult;
3216 if (!const_true_cond)
3220 context->case_val = save_case_val;
3230 newcase->casetype = caseexpr->casetype;
3231 newcase->casecollid = caseexpr->casecollid;
3232 newcase->
arg = (
Expr *) newarg;
3233 newcase->
args = newargs;
3236 return (
Node *) newcase;
3238 case T_CaseTestExpr:
3250 case T_SubscriptingRef:
3277 case T_CoalesceExpr:
3285 foreach(
arg, coalesceexpr->
args)
3302 if (((
Const *)
e)->constisnull)
3319 coalesceexpr->coalescecollid);
3322 newcoalesce->coalescetype = coalesceexpr->coalescetype;
3323 newcoalesce->coalescecollid = coalesceexpr->coalescecollid;
3324 newcoalesce->
args = newargs;
3326 return (
Node *) newcoalesce;
3328 case T_SQLValueFunction:
3379 ((
Var *)
arg)->varlevelsup == 0)
3383 fselect->resulttype,
3384 fselect->resulttypmod,
3385 fselect->resultcollid))
3391 fselect->resulttype,
3392 fselect->resulttypmod,
3393 fselect->resultcollid,
3394 ((
Var *)
arg)->varlevelsup);
3396 newvar->varnullingrels = ((
Var *)
arg)->varnullingrels;
3397 return (
Node *) newvar;
3412 fselect->resulttype,
3413 fselect->resulttypmod,
3414 fselect->resultcollid) &&
3415 fselect->resulttype ==
exprType(fld) &&
3424 newfselect->resulttype = fselect->resulttype;
3425 newfselect->resulttypmod = fselect->resulttypmod;
3426 newfselect->resultcollid = fselect->resultcollid;
3433 newfselect->resulttype,
3434 newfselect->resulttypmod,
3435 newfselect->resultcollid))
3438 return (
Node *) newfselect;
3460 foreach(l, rarg->
args)
3472 if (carg->constisnull ?
3486 newntest->
arg = (
Expr *) relem;
3488 newntest->argisrow =
false;
3490 newargs =
lappend(newargs, newntest);
3509 result = carg->constisnull;
3512 result = !carg->constisnull;
3515 elog(
ERROR,
"unrecognized nulltesttype: %d",
3527 newntest->argisrow = ntest->argisrow;
3529 return (
Node *) newntest;
3554 result = (!carg->constisnull &&
3558 result = (carg->constisnull ||
3562 result = (!carg->constisnull &&
3566 result = (carg->constisnull ||
3570 result = carg->constisnull;
3573 result = !carg->constisnull;
3576 elog(
ERROR,
"unrecognized booltesttype: %d",
3589 return (
Node *) newbtest;
3591 case T_CoerceToDomain:
3620 cdomain->resulttypmod,
3621 cdomain->resultcollid,
3622 cdomain->coercionformat,
3630 newcdomain->resulttypmod = cdomain->resulttypmod;
3631 newcdomain->resultcollid = cdomain->resultcollid;
3632 newcdomain->coercionformat = cdomain->coercionformat;
3634 return (
Node *) newcdomain;
3636 case T_PlaceHolderVar:
3653 case T_ConvertRowtypeExpr:
3664 newcre->convertformat = cre->convertformat;
3690 newcre->convertformat = argcre->convertformat;
3697 return (
Node *) newcre;
3750 if (provolatile == PROVOLATILE_IMMUTABLE)
3752 if (
context->estimate && provolatile == PROVOLATILE_STABLE)
3779 bool *haveNull,
bool *forceTrue)
3782 List *unprocessed_args;
3796 while (unprocessed_args)
3806 List *oldlist = unprocessed_args;
3839 if (const_input->constisnull)
3885 bool *haveNull,
bool *forceFalse)
3888 List *unprocessed_args;
3892 while (unprocessed_args)
3902 List *oldlist = unprocessed_args;
3935 if (const_input->constisnull)
3988 if (opno == BooleanEqualOperator)
4003 if (rightop &&
IsA(rightop,
Const))
4006 if (opno == BooleanEqualOperator)
4047 Oid result_collid,
Oid input_collid,
List **args_p,
4048 bool funcvariadic,
bool process_args,
bool allow_non_const,
4070 elog(
ERROR,
"cache lookup failed for function %u", funcid);
4092 result_collid, input_collid,
4096 if (!newexpr && allow_non_const &&
OidIsValid(func_form->prosupport))
4108 fexpr.
xpr.type = T_FuncExpr;
4110 fexpr.funcresulttype = result_type;
4111 fexpr.funcretset = func_form->proretset;
4112 fexpr.funcvariadic = funcvariadic;
4114 fexpr.funccollid = result_collid;
4115 fexpr.inputcollid = input_collid;
4119 req.
type = T_SupportRequestSimplify;
4131 if (!newexpr && allow_non_const)
4133 input_collid,
args, funcvariadic,
4166 Oid *proargtypes = funcform->proargtypes.values;
4168 bool has_named_args =
false;
4179 if (include_out_arguments)
4181 Datum proallargtypes;
4185 Anum_pg_proc_proallargtypes,
4196 elog(
ERROR,
"proallargtypes is not a 1-D Oid array or it contains nulls");
4209 has_named_args =
true;
4253 elog(
ERROR,
"too many function arguments");
4266 argarray[
i++] =
arg;
4286 i =
pronargs - funcform->pronargdefaults;
4287 foreach(lc, defaults)
4289 if (argarray[
i] == NULL)
4325 elog(
ERROR,
"not enough default arguments");
4340 Datum proargdefaults;
4344 Anum_pg_proc_proargdefaults);
4379 elog(
ERROR,
"too many function arguments");
4386 memcpy(declared_arg_types, proargtypes,
pronargs *
sizeof(
Oid));
4390 funcform->prorettype,
4393 if (rettype != result_type)
4394 elog(
ERROR,
"function's resolved result type changed during planning");
4419 bool has_nonconst_input =
false;
4420 bool has_null_input =
false;
4427 if (funcform->proretset)
4440 if (funcform->prorettype == RECORDOID)
4451 has_nonconst_input =
true;
4460 if (funcform->proisstrict && has_null_input)
4469 if (has_nonconst_input)
4479 if (funcform->provolatile == PROVOLATILE_IMMUTABLE)
4481 else if (
context->estimate && funcform->provolatile == PROVOLATILE_STABLE)
4492 newexpr->
funcid = funcid;
4493 newexpr->funcresulttype = result_type;
4494 newexpr->funcretset =
false;
4495 newexpr->funcvariadic = funcvariadic;
4497 newexpr->funccollid = result_collid;
4498 newexpr->inputcollid = input_collid;
4556 List *raw_parsetree_list;
4557 List *querytree_list;
4568 if (funcform->prolang != SQLlanguageId ||
4569 funcform->prokind != PROKIND_FUNCTION ||
4570 funcform->prosecdef ||
4571 funcform->proretset ||
4572 funcform->prorettype == RECORDOID ||
4605 fexpr->funcresulttype = result_type;
4606 fexpr->funcretset =
false;
4607 fexpr->funcvariadic = funcvariadic;
4609 fexpr->funccollid = result_collid;
4610 fexpr->inputcollid = input_collid;
4623 callback_arg.
prosrc = src;
4626 sqlerrcontext.
arg = (
void *) &callback_arg;
4633 Anum_pg_proc_prosqlbody,
4728 result_type, rettupdesc,
4751 if (
exprType(newexpr) != result_type)
4762 if (funcform->provolatile == PROVOLATILE_IMMUTABLE &&
4765 else if (funcform->provolatile == PROVOLATILE_STABLE &&
4769 if (funcform->proisstrict &&
4786 usecounts = (
int *)
palloc0(funcform->pronargs *
sizeof(
int));
4796 if (usecounts[
i] == 0)
4799 if (funcform->proisstrict)
4802 else if (usecounts[
i] != 1)
4850 if (
OidIsValid(exprcoll) && exprcoll != result_collid)
4854 newnode->
arg = (
Expr *) newexpr;
4855 newnode->
collOid = result_collid;
4858 newexpr = (
Node *) newnode;
4879 return (
Expr *) newexpr;
4901 context.usecounts = usecounts;
4939 int syntaxerrposition;
4943 if (syntaxerrposition > 0)
4961 Oid result_collation)
4969 bool resultTypByVal;
5016 if (resultTypLen == -1)
5019 const_val =
datumCopy(const_val, resultTypByVal, resultTypLen);
5028 return (
Expr *)
makeConst(result_type, result_typmod, result_collation,
5030 const_val, const_is_null,
5069 List *raw_parsetree_list;
5070 List *querytree_list;
5096 func_oid = fexpr->
funcid;
5103 if (!fexpr->funcretset)
5132 elog(
ERROR,
"cache lookup failed for function %u", func_oid);
5145 if (funcform->prolang != SQLlanguageId ||
5146 funcform->prokind != PROKIND_FUNCTION ||
5147 funcform->proisstrict ||
5148 funcform->provolatile == PROVOLATILE_VOLATILE ||
5149 funcform->prorettype == VOIDOID ||
5150 funcform->prosecdef ||
5151 !funcform->proretset ||
5164 "inline_set_returning_function",
5177 callback_arg.
prosrc = src;
5180 sqlerrcontext.
arg = (
void *) &callback_arg;
5187 Anum_pg_proc_prosqlbody,
5218 fexpr->inputcollid);
5243 if (rtfunc->funccolnames !=
NIL)
5247 rtfunc->funccoltypes,
5248 rtfunc->funccoltypmods,
5249 rtfunc->funccolcollations);
5275 fexpr->funcresulttype, rettupdesc,
5324 root->glob->dependsOnRole =
true;
Datum querytree(PG_FUNCTION_ARGS)
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
#define DatumGetArrayTypeP(X)
int ArrayGetNItems(int ndim, const int *dims)
#define InvalidAttrNumber
Bitmapset * bms_join(Bitmapset *a, Bitmapset *b)
void bms_free(Bitmapset *a)
int bms_num_members(const Bitmapset *a)
Bitmapset * bms_make_singleton(int x)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_int_members(Bitmapset *a, const Bitmapset *b)
BMS_Membership bms_membership(const Bitmapset *a)
#define TextDatumGetCString(d)
#define Assert(condition)
#define OidIsValid(objectId)
static bool contain_subplans_walker(Node *node, void *context)
#define CCDN_CASETESTEXPR_OK
static List * simplify_or_arguments(List *args, eval_const_expressions_context *context, bool *haveNull, bool *forceTrue)
static bool is_strict_saop(ScalarArrayOpExpr *expr, bool falseOK)
bool contain_volatile_functions_not_nextval(Node *clause)
static bool contain_leaked_vars_checker(Oid func_id, void *context)
static bool rowtype_field_matches(Oid rowtypeid, int fieldnum, Oid expectedtype, int32 expectedtypmod, Oid expectedcollation)
WindowFuncLists * find_window_functions(Node *clause, Index maxWinRef)
static bool contain_nonstrict_functions_walker(Node *node, void *context)
static List * add_function_defaults(List *args, int pronargs, HeapTuple func_tuple)
#define ece_all_arguments_const(node)
Expr * evaluate_expr(Expr *expr, Oid result_type, int32 result_typmod, Oid result_collation)
#define ece_evaluate_expr(node)
static bool max_parallel_hazard_checker(Oid func_id, void *context)
static bool max_parallel_hazard_test(char proparallel, max_parallel_hazard_context *context)
bool contain_agg_clause(Node *clause)
static Node * substitute_actual_srf_parameters_mutator(Node *node, substitute_actual_srf_parameters_context *context)
static bool contain_agg_clause_walker(Node *node, void *context)
static bool contain_nonstrict_functions_checker(Oid func_id, void *context)
int NumRelids(PlannerInfo *root, Node *clause)
bool contain_mutable_functions(Node *clause)
bool is_pseudo_constant_clause(Node *clause)
static bool max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)
bool contain_window_function(Node *clause)
#define ece_generic_processing(node)
static Expr * evaluate_function(Oid funcid, Oid result_type, int32 result_typmod, Oid result_collid, Oid input_collid, List *args, bool funcvariadic, HeapTuple func_tuple, eval_const_expressions_context *context)
static Node * substitute_actual_parameters_mutator(Node *node, substitute_actual_parameters_context *context)
static bool contain_mutable_functions_checker(Oid func_id, void *context)
bool is_pseudo_constant_clause_relids(Node *clause, Relids relids)
List * expand_function_arguments(List *args, bool include_out_arguments, Oid result_type, HeapTuple func_tuple)
static Query * substitute_actual_srf_parameters(Query *expr, int nargs, List *args)
Var * find_forced_null_var(Node *node)
static bool ece_function_is_safe(Oid funcid, eval_const_expressions_context *context)
static bool contain_volatile_functions_checker(Oid func_id, void *context)
static List * simplify_and_arguments(List *args, eval_const_expressions_context *context, bool *haveNull, bool *forceFalse)
List * find_forced_null_vars(Node *node)
static Expr * simplify_function(Oid funcid, Oid result_type, int32 result_typmod, Oid result_collid, Oid input_collid, List **args_p, bool funcvariadic, bool process_args, bool allow_non_const, eval_const_expressions_context *context)
bool contain_volatile_functions_after_planning(Expr *expr)
static Expr * inline_function(Oid funcid, Oid result_type, Oid result_collid, Oid input_collid, List *args, bool funcvariadic, HeapTuple func_tuple, eval_const_expressions_context *context)
static List * reorder_function_arguments(List *args, int pronargs, HeapTuple func_tuple)
static Node * substitute_actual_parameters(Node *expr, int nargs, List *args, int *usecounts)
static bool contain_mutable_functions_walker(Node *node, void *context)
Query * inline_set_returning_function(PlannerInfo *root, RangeTblEntry *rte)
bool contain_mutable_functions_after_planning(Expr *expr)
static bool contain_volatile_functions_walker(Node *node, void *context)
bool contain_leaked_vars(Node *clause)
static Relids find_nonnullable_rels_walker(Node *node, bool top_level)
Bitmapset * pull_paramids(Expr *expr)
void convert_saop_to_hashed_saop(Node *node)
static void sql_inline_error_callback(void *arg)
static bool contain_volatile_functions_not_nextval_walker(Node *node, void *context)
static bool contain_leaked_vars_walker(Node *node, void *context)
static bool contain_non_const_walker(Node *node, void *context)
static bool contain_context_dependent_node(Node *clause)
Relids find_nonnullable_rels(Node *clause)
static void recheck_cast_function_args(List *args, Oid result_type, Oid *proargtypes, int pronargs, HeapTuple func_tuple)
static bool find_window_functions_walker(Node *node, WindowFuncLists *lists)
List * find_nonnullable_vars(Node *clause)
char max_parallel_hazard(Query *parse)
bool is_parallel_safe(PlannerInfo *root, Node *node)
bool contain_nonstrict_functions(Node *clause)
static bool contain_volatile_functions_not_nextval_checker(Oid func_id, void *context)
static List * find_nonnullable_vars_walker(Node *node, bool top_level)
Node * eval_const_expressions(PlannerInfo *root, Node *node)
bool contain_subplans(Node *clause)
static Node * simplify_boolean_equality(Oid opno, List *args)
static bool contain_exec_param_walker(Node *node, List *param_ids)
void CommuteOpExpr(OpExpr *clause)
static Node * eval_const_expressions_mutator(Node *node, eval_const_expressions_context *context)
static bool pull_paramids_walker(Node *node, Bitmapset **context)
static bool convert_saop_to_hashed_saop_walker(Node *node, void *context)
static List * fetch_function_defaults(HeapTuple func_tuple)
bool contain_volatile_functions(Node *clause)
double expression_returns_set_rows(PlannerInfo *root, Node *clause)
static bool contain_context_dependent_node_walker(Node *node, int *flags)
bool contain_exec_param(Node *clause, List *param_ids)
#define MIN_ARRAY_SIZE_FOR_HASHED_SAOP
Node * estimate_expression_value(PlannerInfo *root, Node *node)
void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root)
double clamp_row_est(double nrows)
Datum datumCopy(Datum value, bool typByVal, int typLen)
static void PGresult * res
int internalerrquery(const char *query)
int internalerrposition(int cursorpos)
ErrorContextCallback * error_context_stack
int errposition(int cursorpos)
ExprState * ExecInitExpr(Expr *node, PlanState *parent)
EState * CreateExecutorState(void)
void FreeExecutorState(EState *estate)
#define GetPerTupleExprContext(estate)
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
#define OidFunctionCall1(functionId, arg1)
#define PG_DETOAST_DATUM_COPY(datum)
#define FmgrHookIsNeeded(fn_oid)
TypeFuncClass get_expr_result_type(Node *expr, Oid *resultTypeId, TupleDesc *resultTupleDesc)
@ TYPEFUNC_COMPOSITE_DOMAIN
void sql_fn_parser_setup(struct ParseState *pstate, SQLFunctionParseInfoPtr pinfo)
bool check_sql_fn_retval(List *queryTreeLists, Oid rettype, TupleDesc rettupdesc, char prokind, bool insertDroppedCols, List **resultTargetList)
SQLFunctionParseInfoPtr prepare_sql_fn_parse_info(HeapTuple procedureTuple, Node *call_expr, Oid inputCollation)
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
#define HeapTupleIsValid(tuple)
if(TABLE==NULL||TABLE_index==NULL)
bool to_json_is_immutable(Oid typoid)
bool to_jsonb_is_immutable(Oid typoid)
bool jspIsMutable(JsonPath *path, List *varnames, List *varexprs)
static JsonPath * DatumGetJsonPathP(Datum d)
List * list_delete_first_n(List *list, int n)
List * lappend(List *list, void *datum)
List * lappend_oid(List *list, Oid datum)
List * list_copy(const List *oldlist)
List * list_delete_first(List *list)
void list_free(List *list)
bool list_member_int(const List *list, int datum)
bool list_member_oid(const List *list, Oid datum)
List * list_concat(List *list1, const List *list2)
bool list_member(const List *list, const void *datum)
List * list_concat_copy(const List *list1, const List *list2)
List * list_delete_last(List *list)
char func_parallel(Oid funcid)
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
RegProcedure get_opcode(Oid opno)
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
char func_volatile(Oid funcid)
bool func_strict(Oid funcid)
bool get_func_leakproof(Oid funcid)
const struct SubscriptRoutines * getSubscriptingRoutines(Oid typid, Oid *typelemp)
bool get_op_hash_functions(Oid opno, RegProcedure *lhs_procno, RegProcedure *rhs_procno)
Oid get_negator(Oid opno)
Oid get_commutator(Oid opno)
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Expr * make_andclause(List *andclauses)
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Node * makeBoolConst(bool value, bool isnull)
Expr * make_orclause(List *orclauses)
void pfree(void *pointer)
void * palloc0(Size size)
MemoryContext CurrentMemoryContext
void MemoryContextDelete(MemoryContext context)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
List * mbms_int_members(List *a, const List *b)
List * mbms_add_member(List *a, int listidx, int bitidx)
List * mbms_add_members(List *a, const List *b)
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
bool check_functions_in_node(Node *node, check_function_callback checker, void *context)
Oid exprCollation(const Node *expr)
Node * applyRelabelType(Node *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat, int rlocation, bool overwrite_ok)
void fix_opfuncids(Node *node)
void set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
void set_opfuncid(OpExpr *opexpr)
#define expression_tree_mutator(n, m, c)
static bool is_andclause(const void *clause)
static bool is_orclause(const void *clause)
#define query_tree_walker(q, w, c, f)
static bool is_opclause(const void *clause)
#define expression_tree_walker(n, w, c)
#define query_tree_mutator(q, m, c, f)
#define IsA(nodeptr, _type_)
#define castNode(_type_, nodeptr)
void(* ParserSetupHook)(struct ParseState *pstate, void *arg)
Oid enforce_generic_type_consistency(const Oid *actual_arg_types, Oid *declared_arg_types, int nargs, Oid rettype, bool allow_poly)
void make_fn_arguments(ParseState *pstate, List *fargs, Oid *actual_arg_types, Oid *declared_arg_types)
void free_parsestate(ParseState *pstate)
ParseState * make_parsestate(ParseState *parentParseState)
Query * transformTopLevelStmt(ParseState *pstate, RawStmt *parseTree)
FormData_pg_attribute * Form_pg_attribute
#define lfirst_node(type, lc)
static int list_length(const List *l)
#define linitial_node(type, l)
#define forthree(cell1, list1, cell2, list2, cell3, list3)
#define list_make3(x1, x2, x3)
static void * list_nth(const List *list, int n)
FormData_pg_proc * Form_pg_proc
double get_function_rows(PlannerInfo *root, Oid funcid, Node *node)
Expr * expression_planner(Expr *expr)
List * pg_parse_query(const char *query_string)
List * pg_analyze_and_rewrite_withcb(RawStmt *parsetree, const char *query_string, ParserSetupHook parserSetup, void *parserSetupArg, QueryEnvironment *queryEnv)
List * pg_rewrite_query(Query *query)
void check_stack_depth(void)
static bool DatumGetBool(Datum X)
static Datum PointerGetDatum(const void *X)
static Datum BoolGetDatum(bool X)
static Datum ObjectIdGetDatum(Oid X)
static Pointer DatumGetPointer(Datum X)
static Datum Int32GetDatum(int32 X)
Node * negate_clause(Node *node)
MemoryContextSwitchTo(old_ctx)
void * stringToNode(const char *str)
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
void AcquireRewriteLocks(Query *parsetree, bool forExecute, bool forUpdatePushedDown)
bool contain_windowfuncs(Node *node)
void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up, int min_sublevels_up)
void record_plan_type_dependency(PlannerInfo *root, Oid typid)
void record_plan_function_dependency(PlannerInfo *root, Oid funcid)
BoolTestType booltesttype
MemoryContext es_query_cxt
struct ErrorContextCallback * previous
void(* callback)(void *arg)
JsonReturning * returning
NullTestType nulltesttype
ParamExternData params[FLEXIBLE_ARRAY_MEMBER]
ParamFetchHook paramFetch
const char * p_sourcetext
VolatileFunctionStatus has_volatile_expr
struct PlannerInfo * root
ParamListInfo boundParams
#define FirstLowInvalidHeapAttributeNumber
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
TupleDesc BuildDescFromLists(const List *names, const List *types, const List *typmods, const List *collations)
#define ReleaseTupleDesc(tupdesc)
#define TupleDescAttr(tupdesc, i)
TupleDesc lookup_rowtype_tupdesc_domain(Oid type_id, int32 typmod, bool noError)
bool DomainHasConstraints(Oid type_id)
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
#define TYPECACHE_CMP_PROC
bool contain_var_clause(Node *node)
Relids pull_varnos(PlannerInfo *root, Node *node)