50 #include "utils/fmgroids.h"
118 bool *haveNull,
bool *forceTrue);
121 bool *haveNull,
bool *forceFalse);
124 Oid result_type,
int32 result_typmod,
125 Oid result_collid,
Oid input_collid,
List **args_p,
126 bool funcvariadic,
bool process_args,
bool allow_non_const,
248 elog(
ERROR,
"WindowFunc contains out-of-range winref %u",
296 if (expr->funcretset)
404 foreach(lc, ctor->
args)
661 return (func_id != F_NEXTVAL &&
758 for (proot = root; proot != NULL; proot = proot->parent_root)
778 case PROPARALLEL_SAFE:
781 case PROPARALLEL_RESTRICTED:
789 case PROPARALLEL_UNSAFE:
794 elog(
ERROR,
"unrecognized proparallel value \"%c\"", proparallel);
885 List *save_safe_param_ids;
1166 #define CCDN_CASETESTEXPR_OK 0x0001
1186 int save_flags = *flags;
1201 *flags = save_flags;
1216 save_flags = *flags;
1220 *flags = save_flags;
1268 case T_NamedArgExpr:
1273 case T_CaseTestExpr:
1275 case T_SQLValueFunction:
1278 case T_NextValueExpr:
1289 case T_DistinctExpr:
1291 case T_ScalarArrayOpExpr:
1293 case T_ArrayCoerceExpr:
1305 case T_SubscriptingRef:
1325 case T_RowCompareExpr:
1338 larg, rcexpr->
largs,
1339 rarg, rcexpr->
rargs)
1381 case T_CurrentOfExpr:
1467 foreach(l, (
List *) node)
1526 foreach(l, expr->
args)
1720 foreach(l, (
List *) node)
1784 foreach(l, expr->
args)
1919 foreach(l, (
List *) node)
2015 if (expr->
useOr && falseOK)
2020 if (rightop &&
IsA(rightop,
Const))
2022 Datum arraydatum = ((
Const *) rightop)->constvalue;
2023 bool arrayisnull = ((
Const *) rightop)->constisnull;
2038 if (arrayexpr->
elements !=
NIL && !arrayexpr->multidims)
2135 elog(
ERROR,
"cannot commute non-binary-operator clause");
2140 elog(
ERROR,
"could not find commutator for operator %u",
2146 clause->
opno = opoid;
2167 Oid expectedtype,
int32 expectedtypmod,
2168 Oid expectedcollation)
2174 if (rowtypeid == RECORDOID)
2177 if (fieldnum <= 0 || fieldnum > tupdesc->
natts)
2183 if (attr->attisdropped ||
2184 attr->atttypid != expectedtype ||
2185 attr->atttypmod != expectedtypmod ||
2186 attr->attcollation != expectedcollation)
2242 context.
root = root;
2249 #define MIN_ARRAY_SIZE_FOR_HASHED_SAOP 9
2285 if (arrayarg &&
IsA(arrayarg,
Const) &&
2286 !((
Const *) arrayarg)->constisnull)
2291 lefthashfunc == righthashfunc)
2293 Datum arrdatum = ((
Const *) arrayarg)->constvalue;
2307 saop->hashfuncid = lefthashfunc;
2323 lefthashfunc == righthashfunc)
2325 Datum arrdatum = ((
Const *) arrayarg)->constvalue;
2339 saop->hashfuncid = lefthashfunc;
2381 context.
root = NULL;
2397 #define ece_generic_processing(node) \
2398 expression_tree_mutator((Node *) (node), eval_const_expressions_mutator, \
2406 #define ece_all_arguments_const(node) \
2407 (!expression_tree_walker((Node *) (node), contain_non_const_walker, NULL))
2410 #define ece_evaluate_expr(node) \
2411 ((Node *) evaluate_expr((Expr *) (node), \
2412 exprType((Node *) (node)), \
2413 exprTypmod((Node *) (node)), \
2414 exprCollation((Node *) (node))))
2481 &typLen, &typByVal);
2482 if (prm->
isnull || typByVal)
2494 return (
Node *) con;
2523 elog(
ERROR,
"cache lookup failed for function %u", funcid);
2526 false, expr->wintype,
2537 aggfilter = (
Expr *)
2544 newexpr->wintype = expr->wintype;
2545 newexpr->wincollid = expr->wincollid;
2546 newexpr->inputcollid = expr->inputcollid;
2550 newexpr->winstar = expr->winstar;
2551 newexpr->winagg = expr->winagg;
2554 return (
Node *) newexpr;
2571 expr->funcresulttype,
2581 return (
Node *) simple;
2591 newexpr->funcresulttype = expr->funcresulttype;
2592 newexpr->funcretset = expr->funcretset;
2593 newexpr->funcvariadic = expr->funcvariadic;
2594 newexpr->funcformat = expr->funcformat;
2595 newexpr->funccollid = expr->funccollid;
2596 newexpr->inputcollid = expr->inputcollid;
2599 return (
Node *) newexpr;
2619 expr->opresulttype, -1,
2628 return (
Node *) simple;
2635 if (expr->
opno == BooleanEqualOperator ||
2636 expr->
opno == BooleanNotEqualOperator)
2641 return (
Node *) simple;
2651 newexpr->opfuncid = expr->opfuncid;
2652 newexpr->opresulttype = expr->opresulttype;
2653 newexpr->opretset = expr->opretset;
2654 newexpr->opcollid = expr->opcollid;
2655 newexpr->inputcollid = expr->inputcollid;
2658 return (
Node *) newexpr;
2660 case T_DistinctExpr:
2665 bool has_null_input =
false;
2666 bool all_null_input =
true;
2667 bool has_nonconst_input =
false;
2694 has_nonconst_input =
true;
2698 if (!has_nonconst_input)
2723 expr->opresulttype, -1,
2739 csimple->constvalue =
2741 return (
Node *) csimple;
2752 newexpr->opfuncid = expr->opfuncid;
2753 newexpr->opresulttype = expr->opresulttype;
2754 newexpr->opretset = expr->opretset;
2755 newexpr->opcollid = expr->opcollid;
2756 newexpr->inputcollid = expr->inputcollid;
2759 return (
Node *) newexpr;
2765 bool has_nonconst_input =
false;
2774 has_nonconst_input =
true;
2785 if (!has_nonconst_input &&
2789 return (
Node *) expr;
2791 case T_ScalarArrayOpExpr:
2808 return (
Node *) saop;
2819 bool haveNull =
false;
2820 bool forceTrue =
false;
2847 bool haveNull =
false;
2848 bool forceFalse =
false;
2894 case T_JsonValueExpr:
2901 if (formatted &&
IsA(formatted,
Const))
2907 case T_AlternativeSubPlan:
2927 relabel->resulttypmod,
2928 relabel->resultcollid,
2929 relabel->relabelformat,
2938 bool outtypisvarlena;
2957 &outfunc, &outtypisvarlena);
2959 &infunc, &intypioparam);
3003 return (
Node *) simple;
3014 newexpr->resultcollid = expr->resultcollid;
3015 newexpr->coerceformat = expr->coerceformat;
3017 return (
Node *) newexpr;
3019 case T_ArrayCoerceExpr:
3022 Node *save_case_val;
3120 Node *save_case_val;
3123 bool const_true_cond;
3124 Node *defresult = NULL;
3143 const_true_cond =
false;
3159 if (casecond &&
IsA(casecond,
Const))
3163 if (const_input->constisnull ||
3167 const_true_cond =
true;
3175 if (!const_true_cond)
3179 newcasewhen->
expr = (
Expr *) casecond;
3182 newargs =
lappend(newargs, newcasewhen);
3191 defresult = caseresult;
3196 if (!const_true_cond)
3210 newcase->casetype = caseexpr->casetype;
3211 newcase->casecollid = caseexpr->casecollid;
3212 newcase->
arg = (
Expr *) newarg;
3213 newcase->
args = newargs;
3216 return (
Node *) newcase;
3218 case T_CaseTestExpr:
3230 case T_SubscriptingRef:
3257 case T_CoalesceExpr:
3265 foreach(
arg, coalesceexpr->
args)
3282 if (((
Const *)
e)->constisnull)
3299 coalesceexpr->coalescecollid);
3302 newcoalesce->coalescetype = coalesceexpr->coalescetype;
3303 newcoalesce->coalescecollid = coalesceexpr->coalescecollid;
3304 newcoalesce->
args = newargs;
3306 return (
Node *) newcoalesce;
3308 case T_SQLValueFunction:
3359 ((
Var *)
arg)->varlevelsup == 0)
3363 fselect->resulttype,
3364 fselect->resulttypmod,
3365 fselect->resultcollid))
3371 fselect->resulttype,
3372 fselect->resulttypmod,
3373 fselect->resultcollid,
3374 ((
Var *)
arg)->varlevelsup);
3376 newvar->varnullingrels = ((
Var *)
arg)->varnullingrels;
3377 return (
Node *) newvar;
3392 fselect->resulttype,
3393 fselect->resulttypmod,
3394 fselect->resultcollid) &&
3395 fselect->resulttype ==
exprType(fld) &&
3404 newfselect->resulttype = fselect->resulttype;
3405 newfselect->resulttypmod = fselect->resulttypmod;
3406 newfselect->resultcollid = fselect->resultcollid;
3413 newfselect->resulttype,
3414 newfselect->resulttypmod,
3415 newfselect->resultcollid))
3418 return (
Node *) newfselect;
3440 foreach(l, rarg->
args)
3452 if (carg->constisnull ?
3466 newntest->
arg = (
Expr *) relem;
3468 newntest->argisrow =
false;
3470 newargs =
lappend(newargs, newntest);
3489 result = carg->constisnull;
3492 result = !carg->constisnull;
3495 elog(
ERROR,
"unrecognized nulltesttype: %d",
3507 newntest->argisrow = ntest->argisrow;
3509 return (
Node *) newntest;
3534 result = (!carg->constisnull &&
3538 result = (carg->constisnull ||
3542 result = (!carg->constisnull &&
3546 result = (carg->constisnull ||
3550 result = carg->constisnull;
3553 result = !carg->constisnull;
3556 elog(
ERROR,
"unrecognized booltesttype: %d",
3569 return (
Node *) newbtest;
3571 case T_CoerceToDomain:
3600 cdomain->resulttypmod,
3601 cdomain->resultcollid,
3602 cdomain->coercionformat,
3610 newcdomain->resulttypmod = cdomain->resulttypmod;
3611 newcdomain->resultcollid = cdomain->resultcollid;
3612 newcdomain->coercionformat = cdomain->coercionformat;
3614 return (
Node *) newcdomain;
3616 case T_PlaceHolderVar:
3633 case T_ConvertRowtypeExpr:
3644 newcre->convertformat = cre->convertformat;
3670 newcre->convertformat = argcre->convertformat;
3677 return (
Node *) newcre;
3730 if (provolatile == PROVOLATILE_IMMUTABLE)
3732 if (context->
estimate && provolatile == PROVOLATILE_STABLE)
3759 bool *haveNull,
bool *forceTrue)
3762 List *unprocessed_args;
3776 while (unprocessed_args)
3786 List *oldlist = unprocessed_args;
3819 if (const_input->constisnull)
3865 bool *haveNull,
bool *forceFalse)
3868 List *unprocessed_args;
3872 while (unprocessed_args)
3882 List *oldlist = unprocessed_args;
3915 if (const_input->constisnull)
3968 if (opno == BooleanEqualOperator)
3983 if (rightop &&
IsA(rightop,
Const))
3986 if (opno == BooleanEqualOperator)
4027 Oid result_collid,
Oid input_collid,
List **args_p,
4028 bool funcvariadic,
bool process_args,
bool allow_non_const,
4050 elog(
ERROR,
"cache lookup failed for function %u", funcid);
4072 result_collid, input_collid,
4074 func_tuple, context);
4076 if (!newexpr && allow_non_const &&
OidIsValid(func_form->prosupport))
4088 fexpr.
xpr.type = T_FuncExpr;
4090 fexpr.funcresulttype = result_type;
4091 fexpr.funcretset = func_form->proretset;
4092 fexpr.funcvariadic = funcvariadic;
4094 fexpr.funccollid = result_collid;
4095 fexpr.inputcollid = input_collid;
4099 req.
type = T_SupportRequestSimplify;
4111 if (!newexpr && allow_non_const)
4113 input_collid,
args, funcvariadic,
4114 func_tuple, context);
4146 Oid *proargtypes = funcform->proargtypes.values;
4148 bool has_named_args =
false;
4159 if (include_out_arguments)
4161 Datum proallargtypes;
4165 Anum_pg_proc_proallargtypes,
4176 elog(
ERROR,
"proallargtypes is not a 1-D Oid array or it contains nulls");
4189 has_named_args =
true;
4233 elog(
ERROR,
"too many function arguments");
4246 argarray[
i++] =
arg;
4266 i =
pronargs - funcform->pronargdefaults;
4267 foreach(lc, defaults)
4269 if (argarray[
i] == NULL)
4305 elog(
ERROR,
"not enough default arguments");
4320 Datum proargdefaults;
4324 Anum_pg_proc_proargdefaults);
4359 elog(
ERROR,
"too many function arguments");
4366 memcpy(declared_arg_types, proargtypes,
pronargs *
sizeof(
Oid));
4370 funcform->prorettype,
4373 if (rettype != result_type)
4374 elog(
ERROR,
"function's resolved result type changed during planning");
4399 bool has_nonconst_input =
false;
4400 bool has_null_input =
false;
4407 if (funcform->proretset)
4421 if (funcform->prorettype == RECORDOID)
4432 has_nonconst_input =
true;
4441 if (funcform->proisstrict && has_null_input)
4450 if (has_nonconst_input)
4460 if (funcform->provolatile == PROVOLATILE_IMMUTABLE)
4462 else if (context->
estimate && funcform->provolatile == PROVOLATILE_STABLE)
4473 newexpr->
funcid = funcid;
4474 newexpr->funcresulttype = result_type;
4475 newexpr->funcretset =
false;
4476 newexpr->funcvariadic = funcvariadic;
4478 newexpr->funccollid = result_collid;
4479 newexpr->inputcollid = input_collid;
4537 List *raw_parsetree_list;
4538 List *querytree_list;
4549 if (funcform->prolang != SQLlanguageId ||
4550 funcform->prokind != PROKIND_FUNCTION ||
4551 funcform->prosecdef ||
4552 funcform->proretset ||
4553 funcform->prorettype == RECORDOID ||
4586 fexpr->funcresulttype = result_type;
4587 fexpr->funcretset =
false;
4588 fexpr->funcvariadic = funcvariadic;
4590 fexpr->funccollid = result_collid;
4591 fexpr->inputcollid = input_collid;
4604 callback_arg.
prosrc = src;
4607 sqlerrcontext.
arg = (
void *) &callback_arg;
4614 Anum_pg_proc_prosqlbody,
4709 result_type, rettupdesc,
4732 if (
exprType(newexpr) != result_type)
4743 if (funcform->provolatile == PROVOLATILE_IMMUTABLE &&
4746 else if (funcform->provolatile == PROVOLATILE_STABLE &&
4750 if (funcform->proisstrict &&
4767 usecounts = (
int *)
palloc0(funcform->pronargs *
sizeof(
int));
4777 if (usecounts[
i] == 0)
4780 if (funcform->proisstrict)
4783 else if (usecounts[
i] != 1)
4831 if (
OidIsValid(exprcoll) && exprcoll != result_collid)
4835 newnode->
arg = (
Expr *) newexpr;
4836 newnode->
collOid = result_collid;
4839 newexpr = (
Node *) newnode;
4860 return (
Expr *) newexpr;
4880 context.
nargs = nargs;
4920 int syntaxerrposition;
4924 if (syntaxerrposition > 0)
4942 Oid result_collation)
4950 bool resultTypByVal;
4997 if (resultTypLen == -1)
5000 const_val =
datumCopy(const_val, resultTypByVal, resultTypLen);
5009 return (
Expr *)
makeConst(result_type, result_typmod, result_collation,
5011 const_val, const_is_null,
5050 List *raw_parsetree_list;
5051 List *querytree_list;
5077 func_oid = fexpr->
funcid;
5084 if (!fexpr->funcretset)
5113 elog(
ERROR,
"cache lookup failed for function %u", func_oid);
5126 if (funcform->prolang != SQLlanguageId ||
5127 funcform->prokind != PROKIND_FUNCTION ||
5128 funcform->proisstrict ||
5129 funcform->provolatile == PROVOLATILE_VOLATILE ||
5130 funcform->prorettype == VOIDOID ||
5131 funcform->prosecdef ||
5132 !funcform->proretset ||
5145 "inline_set_returning_function",
5158 callback_arg.
prosrc = src;
5161 sqlerrcontext.
arg = (
void *) &callback_arg;
5168 Anum_pg_proc_prosqlbody,
5199 fexpr->inputcollid);
5224 if (rtfunc->funccolnames !=
NIL)
5228 rtfunc->funccoltypes,
5229 rtfunc->funccoltypmods,
5230 rtfunc->funccolcollations);
5256 fexpr->funcresulttype, rettupdesc,
5330 context.
nargs = nargs;
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 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)
Assert(fmt[strlen(fmt) - 1] !='\n')
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)
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
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)
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)