39 #include "utils/fmgroids.h"
76 int sublevels_up,
int location);
96 List *largs,
List *rargs,
int location);
209 elog(
ERROR,
"unrecognized A_Expr kind: %d",
a->kind);
299 (
errcode(ERRCODE_SYNTAX_ERROR),
300 errmsg(
"DEFAULT is not allowed in this context"),
318 result = (
Node *) expr;
393 ((
Var *) relref)->varno,
394 ((
Var *) relref)->varlevelsup);
396 (
errcode(ERRCODE_UNDEFINED_COLUMN),
397 errmsg(
"column %s.%s does not exist",
408 (
errcode(ERRCODE_UNDEFINED_COLUMN),
409 errmsg(
"column \"%s\" not found in data type %s",
412 else if (relTypeId == RECORDOID)
414 (
errcode(ERRCODE_UNDEFINED_COLUMN),
415 errmsg(
"could not identify column \"%s\" in record data type",
420 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
421 errmsg(
"column notation .%s applied to type %s, "
422 "which is not a composite type",
442 foreach(
i,
ind->indirection)
447 subscripts =
lappend(subscripts, n);
451 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
452 errmsg(
"row expansion via \"*\" is not supported here"),
478 if (newresult == NULL)
504 char *nspname = NULL;
506 char *colname = NULL;
515 } crerr = CRERR_NO_COLUMN;
574 err =
_(
"cannot use column reference in DEFAULT expression");
577 err =
_(
"cannot use column reference in partition bound expression");
590 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
676 crerr = CRERR_NO_RTE;
726 crerr = CRERR_NO_RTE;
779 crerr = CRERR_WRONG_DB;
789 crerr = CRERR_NO_RTE;
823 crerr = CRERR_TOO_MANY;
843 else if (hookresult != NULL)
845 (
errcode(ERRCODE_AMBIGUOUS_COLUMN),
846 errmsg(
"column reference \"%s\" is ambiguous",
858 case CRERR_NO_COLUMN:
867 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
868 errmsg(
"cross-database references are not implemented: %s",
874 (
errcode(ERRCODE_SYNTAX_ERROR),
875 errmsg(
"improper qualified name (too many dotted names): %s",
901 (
errcode(ERRCODE_UNDEFINED_PARAMETER),
925 Node *lexpr =
a->lexpr;
926 Node *rexpr =
a->rexpr;
1034 Node *lexpr =
a->lexpr;
1035 Node *rexpr =
a->rexpr;
1101 (
errcode(ERRCODE_DATATYPE_MISMATCH),
1102 errmsg(
"NULLIF requires = operator to yield boolean"),
1106 (
errcode(ERRCODE_DATATYPE_MISMATCH),
1108 errmsg(
"%s must not return a set",
"NULLIF"),
1121 return (
Node *) result;
1127 Node *result = NULL;
1155 rexprs = rvars = rnonvars =
NIL;
1156 foreach(l, (
List *)
a->rexpr)
1160 rexprs =
lappend(rexprs, rexpr);
1162 rvars =
lappend(rvars, rexpr);
1164 rnonvars =
lappend(rnonvars, rexpr);
1198 if (
OidIsValid(scalar_type) && scalar_type != RECORDOID)
1212 foreach(l, rnonvars)
1219 aexprs =
lappend(aexprs, rexpr);
1368 elog(
ERROR,
"unrecognized A_Expr kind: %d",
a->kind);
1395 elog(
ERROR,
"unrecognized boolop: %d", (
int)
a->boolop);
1400 foreach(lc,
a->args)
1435 if (
fn->agg_within_group)
1438 foreach(
args,
fn->agg_order)
1469 if (maref->
colno == 1)
1492 (
errcode(ERRCODE_SYNTAX_ERROR),
1493 errmsg(
"number of columns does not match number of values"),
1524 (
errcode(ERRCODE_SYNTAX_ERROR),
1525 errmsg(
"number of columns does not match number of values"),
1538 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1539 errmsg(
"source for a multiple-column UPDATE item must be a sub-SELECT or ROW() expression"),
1576 return (
Node *) param;
1601 elog(
ERROR,
"unexpected expr type in multiassign list");
1666 (
Node *) placeholder,
1680 newargs =
lappend(newargs, neww);
1684 newc->
args = newargs;
1687 defresult = (
Node *)
c->defresult;
1688 if (defresult == NULL)
1694 defresult = (
Node *) n;
1718 foreach(l, newc->
args)
1732 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1734 errmsg(
"set-returning functions are not allowed in %s",
1736 errhint(
"You might be able to move the set-returning function into a LATERAL FROM item."),
1742 return (
Node *) newc;
1797 err =
_(
"cannot use subquery in check constraint");
1801 err =
_(
"cannot use subquery in DEFAULT expression");
1804 err =
_(
"cannot use subquery in index expression");
1807 err =
_(
"cannot use subquery in index predicate");
1810 err =
_(
"cannot use subquery in statistics expression");
1813 err =
_(
"cannot use subquery in transform expression");
1816 err =
_(
"cannot use subquery in EXECUTE parameter");
1819 err =
_(
"cannot use subquery in trigger WHEN condition");
1822 err =
_(
"cannot use subquery in partition bound");
1825 err =
_(
"cannot use subquery in partition key expression");
1828 err =
_(
"cannot use subquery in CALL argument");
1831 err =
_(
"cannot use subquery in COPY FROM WHERE condition");
1834 err =
_(
"cannot use subquery in column generation expression");
1847 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1864 elog(
ERROR,
"unexpected non-SELECT command in SubLink");
1886 (
errcode(ERRCODE_SYNTAX_ERROR),
1887 errmsg(
"subquery must return only one column"),
1922 left_list = ((
RowExpr *) lefthand)->args;
1947 right_list =
lappend(right_list, param);
1957 (
errcode(ERRCODE_SYNTAX_ERROR),
1958 errmsg(
"subquery has too many columns"),
1962 (
errcode(ERRCODE_SYNTAX_ERROR),
1963 errmsg(
"subquery has too few columns"),
2037 newelems =
lappend(newelems, newe);
2056 if (newelems ==
NIL)
2058 (
errcode(ERRCODE_INDETERMINATE_DATATYPE),
2059 errmsg(
"cannot determine type of empty array"),
2060 errhint(
"Explicitly cast to the desired type, "
2061 "for example ARRAY[]::integer[]."),
2073 (
errcode(ERRCODE_UNDEFINED_OBJECT),
2074 errmsg(
"could not find element type for data type %s",
2084 (
errcode(ERRCODE_UNDEFINED_OBJECT),
2085 errmsg(
"could not find array type for data type %s",
2089 coerce_hard =
false;
2118 (
errcode(ERRCODE_CANNOT_COERCE),
2119 errmsg(
"cannot cast type %s to %s",
2128 newcoercedelems =
lappend(newcoercedelems, newe);
2137 return (
Node *) newa;
2161 snprintf(fname,
sizeof(fname),
"f%d", fnum);
2167 return (
Node *) newr;
2179 foreach(
args,
c->args)
2185 newargs =
lappend(newargs, newe);
2192 foreach(
args, newargs)
2200 newcoercedargs =
lappend(newcoercedargs, newe);
2206 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2208 errmsg(
"set-returning functions are not allowed in %s",
2210 errhint(
"You might be able to move the set-returning function into a LATERAL FROM item."),
2214 newc->
args = newcoercedargs;
2216 return (
Node *) newc;
2225 const char *funcname = (m->
op ==
IS_GREATEST) ?
"GREATEST" :
"LEAST";
2235 newargs =
lappend(newargs, newe);
2242 foreach(
args, newargs)
2250 newcoercedargs =
lappend(newcoercedargs, newe);
2253 newm->
args = newcoercedargs;
2255 return (
Node *) newm;
2268 svf->
type = DATEOID;
2271 svf->
type = TIMETZOID;
2274 svf->
type = TIMETZOID;
2278 svf->
type = TIMESTAMPTZOID;
2281 svf->
type = TIMESTAMPTZOID;
2285 svf->
type = TIMEOID;
2288 svf->
type = TIMEOID;
2292 svf->
type = TIMESTAMPOID;
2295 svf->
type = TIMESTAMPOID;
2304 svf->
type = NAMEOID;
2308 return (
Node *) svf;
2325 newx->
type = XMLOID;
2336 foreach(lc,
x->named_args)
2352 (
errcode(ERRCODE_SYNTAX_ERROR),
2354 ?
errmsg(
"unnamed XML attribute value must be a column reference")
2355 :
errmsg(
"unnamed XML element value must be a column reference"),
2369 (
errcode(ERRCODE_SYNTAX_ERROR),
2370 errmsg(
"XML attribute name \"%s\" appears more than once",
2383 foreach(lc,
x->args)
2437 return (
Node *) newx;
2460 xexpr->
type = targetType;
2461 xexpr->
typmod = targetTypmod;
2470 TEXTOID, targetType, targetTypmod,
2476 (
errcode(ERRCODE_CANNOT_COERCE),
2477 errmsg(
"cannot cast XMLSERIALIZE result to %s",
2486 const char *clausename;
2488 switch (
b->booltesttype)
2491 clausename =
"IS TRUE";
2494 clausename =
"IS NOT TRUE";
2497 clausename =
"IS FALSE";
2500 clausename =
"IS NOT FALSE";
2503 clausename =
"IS UNKNOWN";
2506 clausename =
"IS NOT UNKNOWN";
2509 elog(
ERROR,
"unrecognized booltesttype: %d",
2510 (
int)
b->booltesttype);
2555 if (node != NULL &&
IsA(node,
Param))
2569 return (
Node *) cexpr;
2577 int sublevels_up,
int location)
2600 sublevels_up,
true);
2608 return (
Node *) result;
2622 sublevels_up, location,
false,
2632 return (
Node *) rowexpr;
2666 int32 targetBaseTypmod;
2675 targetBaseTypmod = targetTypmod;
2706 targetType, targetTypmod,
2712 (
errcode(ERRCODE_CANNOT_COERCE),
2713 errmsg(
"cannot cast type %s to %s",
2743 (
errcode(ERRCODE_DATATYPE_MISMATCH),
2744 errmsg(
"collations are not supported by type %s",
2751 return (
Node *) newc;
2768 List *largs,
List *rargs,
int location)
2777 List **opinfo_lists;
2785 (
errcode(ERRCODE_SYNTAX_ERROR),
2786 errmsg(
"unequal number of entries in row expressions"),
2795 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2796 errmsg(
"cannot compare rows of zero length"),
2818 if (
cmp->opresulttype != BOOLOID)
2820 (
errcode(ERRCODE_DATATYPE_MISMATCH),
2821 errmsg(
"row comparison operator must yield type boolean, "
2827 (
errcode(ERRCODE_DATATYPE_MISMATCH),
2828 errmsg(
"row comparison operator must not return a set"),
2863 foreach(
j, opinfo_lists[
i])
2870 strats = this_strats;
2886 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2887 errmsg(
"could not determine interpretation of row comparison operator %s",
2889 errhint(
"Row comparison operators must be associated with btree operator families."),
2908 for (
i = 0;
i < nopers;
i++)
2913 foreach(
j, opinfo_lists[
i])
2927 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2928 errmsg(
"could not determine interpretation of row comparison operator %s",
2930 errdetail(
"There are multiple equally-plausible candidates."),
2954 rcexpr->
opnos = opnos;
2957 rcexpr->
largs = largs;
2958 rcexpr->
rargs = rargs;
2960 return (
Node *) rcexpr;
2973 Node *result = NULL;
2981 (
errcode(ERRCODE_SYNTAX_ERROR),
2982 errmsg(
"unequal number of entries in row expressions"),
3020 if (((
OpExpr *) result)->opresulttype != BOOLOID)
3022 (
errcode(ERRCODE_DATATYPE_MISMATCH),
3023 errmsg(
"IS DISTINCT FROM requires = operator to yield boolean"),
3025 if (((
OpExpr *) result)->opretset)
3027 (
errcode(ERRCODE_DATATYPE_MISMATCH),
3029 errmsg(
"%s must not return a set",
"IS DISTINCT FROM"),
3075 return "invalid expression context";
3077 return "extension expression";
3081 return "JOIN/USING";
3083 return "sub-SELECT in FROM";
3085 return "function in FROM";
3095 return "window PARTITION BY";
3097 return "window ORDER BY";
3099 return "window RANGE";
3101 return "window ROWS";
3103 return "window GROUPS";
3112 return "MERGE WHEN";
3118 return "DISTINCT ON";
3135 return "index expression";
3137 return "index predicate";
3139 return "statistics expression";
3147 return "partition bound";
3149 return "PARTITION BY";
3155 return "GENERATED AS";
3166 return "unrecognized expression kind";
3224 return (
Node *) fexpr;
3239 return (
Node *) placeholder;
3257 bool typispreferred;
3274 (
errcode(ERRCODE_DATATYPE_MISMATCH),
3275 errmsg(
"JSON ENCODING clause is only allowed for bytea input type"),
3278 if (exprtype == JSONOID || exprtype == JSONBOID)
3282 (
errmsg(
"FORMAT JSON has no effect for json and jsonb types"),
3305 case TIMESTAMPTZOID:
3309 if (typcategory == TYPCATEGORY_STRING)
3318 else if (exprtype == JSONOID || exprtype == JSONBOID)
3324 (!
OidIsValid(targettype) || exprtype == targettype))
3330 bool cast_is_needed =
OidIsValid(targettype);
3332 if (!isarg && !cast_is_needed &&
3333 exprtype != BYTEAOID && typcategory != TYPCATEGORY_STRING)
3335 (
errcode(ERRCODE_DATATYPE_MISMATCH),
3337 "cannot use non-string types with implicit FORMAT JSON clause" :
3338 "cannot use non-string types with explicit FORMAT JSON clause"),
3369 (
errcode(ERRCODE_CANNOT_COERCE),
3370 errmsg(
"cannot cast type %s to %s",
3375 fnoid = targettype == JSONOID ? F_TO_JSON : F_TO_JSONB;
3381 coerced = (
Node *) fexpr;
3384 if (coerced == orig)
3424 Oid targettype,
bool allow_format_for_non_strings)
3426 if (!allow_format_for_non_strings &&
3428 (targettype != BYTEAOID &&
3429 targettype != JSONOID &&
3430 targettype != JSONBOID))
3433 bool typispreferred;
3437 if (typcategory != TYPCATEGORY_STRING)
3439 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3441 errmsg(
"cannot use JSON format with non-string output types")));
3449 if (targettype != BYTEAOID &&
3452 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3454 errmsg(
"cannot set JSON encoding for non-bytea output types")));
3458 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3459 errmsg(
"unsupported JSON encoding"),
3460 errhint(
"only UTF8 JSON encoding is supported"),
3494 if (
output->typeName->setof)
3496 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3497 errmsg(
"returning SETOF types is not supported in SQL/JSON functions")));
3523 bool have_jsonb =
false;
3530 have_jsonb |= typid == JSONBOID;
3538 returning->
typid = JSONBOID;
3544 returning->
typid = JSONOID;
3576 returning->
typid == BYTEAOID)
3589 return (
Node *) fexpr;
3600 if (!
res && report_error)
3602 (
errcode(ERRCODE_CANNOT_COERCE),
3603 errmsg(
"cannot cast type %s to %s",
3614 bool unique,
bool absent_on_null,
int location)
3619 Oid intermediate_typid =
3623 jsctor->
func = fexpr;
3636 cte->
typeId = intermediate_typid;
3640 placeholder = (
Node *) cte;
3645 if (coercion != placeholder)
3648 return (
Node *) jsctor;
3672 foreach(lc, ctor->
exprs)
3715 (
errcode(ERRCODE_SYNTAX_ERROR),
3716 errmsg(
"subquery must return only one column"),
3732 target->
name = NULL;
3740 range->lateral =
false;
3742 range->alias = alias;
3763 const char *aggfn,
Oid aggtype,
3765 bool unique,
bool absent_on_null)
3796 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3797 errmsg(
"aggregate ORDER BY is not implemented for window functions"),
3803 node = (
Node *) wfunc;
3820 aggref->
aggkind = AGGKIND_NORMAL;
3827 node = (
Node *) aggref;
3831 returning, unique, absent_on_null,
3850 const char *aggfnname;
3864 aggfnname =
"pg_catalog.jsonb_object_agg_unique_strict";
3866 aggfnname =
"pg_catalog.jsonb_object_agg_strict";
3868 aggfnname =
"pg_catalog.jsonb_object_agg_unique";
3870 aggfnname =
"pg_catalog.jsonb_object_agg";
3878 aggfnname =
"pg_catalog.json_object_agg_unique_strict";
3880 aggfnname =
"pg_catalog.json_object_agg_strict";
3882 aggfnname =
"pg_catalog.json_object_agg_unique";
3884 aggfnname =
"pg_catalog.json_object_agg";
3890 args, aggfnname, aggtype,
3907 const char *aggfnname;
3918 "pg_catalog.jsonb_agg_strict" :
"pg_catalog.jsonb_agg";
3924 "pg_catalog.json_agg_strict" :
"pg_catalog.json_agg";
3955 foreach(lc, ctor->
exprs)
3976 Node *expr = raw_expr;
3981 if (*exprtype == BYTEAOID)
3987 *exprtype = TEXTOID;
3992 expr = (
Node *) jve;
3997 bool typispreferred;
4001 if (*exprtype == UNKNOWNOID || typcategory == TYPCATEGORY_STRING)
4007 *exprtype = TEXTOID;
4012 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4014 errmsg(
"cannot use JSON FORMAT ENCODING clause for non-bytea input types")));
4031 if (exprtype != TEXTOID && exprtype != JSONOID && exprtype != JSONBOID)
4033 (
errcode(ERRCODE_DATATYPE_MISMATCH),
4034 errmsg(
"cannot use type %s in IS JSON predicate",
4047 List **passing_values,
List **passing_names)
4051 *passing_values =
NIL;
4052 *passing_names =
NIL;
4062 *passing_values =
lappend(*passing_values, expr);
4075 Node *default_expr = NULL;
4079 behavior_type = behavior->
btype;
4099 (
errcode(ERRCODE_SYNTAX_ERROR),
4100 errmsg(
"JSON_TABLE path name is not allowed here"),
4104 jsexpr->
op = func->
op;
4126 (
errcode(ERRCODE_DATATYPE_MISMATCH),
4127 errmsg(
"JSON path expression must be type %s, not type %s",
4165 is_jsonb =
exprType(context_item) == JSONBOID;
4169 ret->
typid = is_jsonb ? JSONBOID : JSONOID;
4188 if (coercion->
expr == expr)
4189 coercion->
expr = NULL;
4196 if (returning->
typid == RECORDOID ||
4197 typtype == TYPTYPE_COMPOSITE ||
4198 typtype == TYPTYPE_DOMAIN ||
4288 (
errcode(ERRCODE_CANNOT_COERCE),
4289 errmsg(
"cannot cast DEFAULT expression type %s to %s",
4307 if (typid == UNKNOWNOID)
4315 placeholder->
typeId = typid;
4319 expr = (
Node *) placeholder;
4336 {&coercions->
null, UNKNOWNOID},
4337 {&coercions->
string, TEXTOID},
4338 {&coercions->
numeric, NUMERICOID},
4339 {&coercions->
boolean, BOOLOID},
4340 {&coercions->
date, DATEOID},
4341 {&coercions->
time, TIMEOID},
4342 {&coercions->
timetz, TIMETZOID},
4345 {&coercions->
composite, contextItemTypeId},
4349 for (p = coercionTypids; p->coercion; p++)
4360 const char *func_name = NULL;
4366 func_name =
"JSON_VALUE";
4388 func_name =
"JSON_QUERY";
4406 func_name =
"JSON_EXISTS";
4423 placeholder->
typeId = BOOLOID;
4428 jsexpr->result_coercion->expr =
4430 jsexpr->returning->typid,
4431 jsexpr->returning->typmod,
4436 if (!jsexpr->result_coercion->expr)
4438 (
errcode(ERRCODE_CANNOT_COERCE),
4439 errmsg(
"cannot cast type %s to %s",
4444 if (jsexpr->result_coercion->expr == (
Node *) placeholder)
4445 jsexpr->result_coercion->expr = NULL;
4457 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4458 errmsg(
"JSON_TABLE() is not yet implemented for the json type"),
4459 errhint(
"Try casting the argument to jsonb"),
4465 if (
exprType(contextItemExpr) != JSONBOID)
4467 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4468 errmsg(
"%s() is not yet implemented for the json type", func_name),
4469 errhint(
"Try casting the argument to jsonb"),
4472 return (
Node *) jsexpr;
4486 if (returning->
typid != JSONOID && returning->
typid != JSONBOID)
4488 (
errcode(ERRCODE_DATATYPE_MISMATCH),
4489 errmsg(
"cannot use RETURNING type %s in %s",
4495 Oid targettype = JSONOID;
4500 returning->
typid = targettype;
4529 if (arg_type != TEXTOID)
4531 (
errcode(ERRCODE_DATATYPE_MISMATCH),
4532 errmsg(
"cannot use non-string types with WITH UNIQUE KEYS clause"),
4542 false, returning->
typid);
4564 returning,
false,
false, jsexpr->
location);
4583 returning->
typid = TEXTOID;
4588 NULL, returning,
false,
false, expr->
location);
#define InvalidAttrNumber
int32 anytimestamp_typmod_check(bool istz, int32 typmod)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Bitmapset * bms_int_members(Bitmapset *a, const Bitmapset *b)
int bms_first_member(Bitmapset *a)
#define OidIsValid(objectId)
int32 anytime_typmod_check(bool istz, int32 typmod)
char * get_database_name(Oid dbid)
static void PGresult * res
int errmsg_internal(const char *fmt,...)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
#define DirectFunctionCall1(func, arg1)
Assert(fmt[strlen(fmt) - 1] !='\n')
List * list_truncate(List *list, int new_size)
List * lappend(List *list, void *datum)
List * lappend_oid(List *list, Oid datum)
List * list_concat(List *list1, const List *list2)
List * lcons(void *datum, List *list)
List * list_delete_last(List *list)
Oid get_element_type(Oid typid)
bool type_is_rowtype(Oid typid)
List * get_op_btree_interpretation(Oid opno)
bool type_is_collatable(Oid typid)
char get_typtype(Oid typid)
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Oid get_array_type(Oid typid)
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
#define type_is_array(typid)
Var * makeWholeRowVar(RangeTblEntry *rte, int varno, Index varlevelsup, bool allowScalar)
JsonBehavior * makeJsonBehavior(JsonBehaviorType type, Node *default_expr)
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
JsonValueExpr * makeJsonValueExpr(Expr *expr, JsonFormat *format)
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
JsonFormat * makeJsonFormat(JsonFormatType type, JsonEncoding encoding, int location)
Expr * makeBoolExpr(BoolExprType boolop, List *args, int location)
Node * makeBoolConst(bool value, bool isnull)
Node * makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType item_type, bool unique_keys, int location)
A_Expr * makeSimpleA_Expr(A_Expr_Kind kind, char *name, Node *lexpr, Node *rexpr, int location)
char * pstrdup(const char *in)
void namestrcpy(Name name, const char *str)
char * NameListToString(List *names)
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
Oid exprCollation(const Node *expr)
int exprLocation(const Node *expr)
bool expression_returns_set(Node *clause)
#define IsA(nodeptr, _type_)
@ T_JsonObjectConstructor
@ T_JsonArrayQueryConstructor
#define NodeSetTag(nodeptr, t)
#define castNode(_type_, nodeptr)
Node * transformGroupingFunc(ParseState *pstate, GroupingFunc *p)
void transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc, WindowDef *windef)
void transformAggregateCall(ParseState *pstate, Aggref *agg, List *args, List *aggorder, bool agg_distinct)
Node * transformWhereClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName)
Node * coerce_to_common_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *context)
Node * coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod, CoercionContext ccontext, CoercionForm cformat, int location)
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
bool verify_common_type(Oid common_type, List *exprs)
Node * coerce_to_boolean(ParseState *pstate, Node *node, const char *constructName)
int parser_coercion_errposition(ParseState *pstate, int coerce_location, Node *input_expr)
Node * coerce_to_specific_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *constructName)
Oid select_common_type(ParseState *pstate, List *exprs, const char *context, Node **which_expr)
void assign_expr_collations(ParseState *pstate, Node *expr)
static JsonReturning * transformJsonOutput(ParseState *pstate, const JsonOutput *output, bool allow_format)
static Node * make_nulltest_from_distinct(ParseState *pstate, A_Expr *distincta, Node *arg)
static void unknown_attribute(ParseState *pstate, Node *relref, const char *attname, int location)
static Node * makeJsonByteaToTextConversion(Node *expr, JsonFormat *format, int location)
static void assignDefaultJsonReturningType(Node *context_item, JsonFormat *context_format, JsonReturning *ret)
static Node * transformJsonArrayConstructor(ParseState *pstate, JsonArrayConstructor *ctor)
static Node * transformJsonScalarExpr(ParseState *pstate, JsonScalarExpr *expr)
static Node * transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
static Node * transformAExprOpAll(ParseState *pstate, A_Expr *a)
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
static Node * transformAExprIn(ParseState *pstate, A_Expr *a)
static JsonReturning * transformJsonConstructorOutput(ParseState *pstate, JsonOutput *output, List *args)
static void checkJsonOutputFormat(ParseState *pstate, const JsonFormat *format, Oid targettype, bool allow_format_for_non_strings)
static Node * transformJsonIsPredicate(ParseState *pstate, JsonIsPredicate *p)
static Node * transformAExprOpAny(ParseState *pstate, A_Expr *a)
static Node * transformXmlSerialize(ParseState *pstate, XmlSerialize *xs)
static Node * transformExprRecurse(ParseState *pstate, Node *expr)
static Node * transformAExprNullIf(ParseState *pstate, A_Expr *a)
static Node * coerceDefaultJsonExpr(ParseState *pstate, JsonExpr *jsexpr, Node *defexpr)
static JsonCoercion * initJsonItemCoercion(ParseState *pstate, Oid typid, const JsonReturning *returning)
static JsonBehavior * transformJsonBehavior(ParseState *pstate, JsonBehavior *behavior, JsonBehaviorType default_behavior)
static void initJsonItemCoercions(ParseState *pstate, JsonItemCoercions *coercions, const JsonReturning *returning, Oid contextItemTypeId)
static bool exprIsNullConstant(Node *arg)
static Expr * make_distinct_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree, int location)
static Node * transformJsonArrayQueryConstructor(ParseState *pstate, JsonArrayQueryConstructor *ctor)
static Node * transformSQLValueFunction(ParseState *pstate, SQLValueFunction *svf)
static Node * transformColumnRef(ParseState *pstate, ColumnRef *cref)
static JsonCoercion * coerceJsonExpr(ParseState *pstate, Node *expr, const JsonReturning *returning)
static Node * transformCollateClause(ParseState *pstate, CollateClause *c)
static Node * transformBoolExpr(ParseState *pstate, BoolExpr *a)
static JsonReturning * transformJsonConstructorRet(ParseState *pstate, JsonOutput *output, const char *fname)
static Node * transformFuncCall(ParseState *pstate, FuncCall *fn)
static void transformJsonFuncExprOutput(ParseState *pstate, JsonFuncExpr *func, JsonExpr *jsexpr)
static Node * makeJsonConstructorExpr(ParseState *pstate, JsonConstructorType type, List *args, Expr *fexpr, JsonReturning *returning, bool unique, bool absent_on_null, int location)
static Node * transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m)
static Node * transformJsonValueExpr(ParseState *pstate, JsonValueExpr *jve)
static Node * transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c)
bool Transform_null_equals
static Node * transformSubLink(ParseState *pstate, SubLink *sublink)
static Node * transformJsonObjectConstructor(ParseState *pstate, JsonObjectConstructor *ctor)
static Node * make_row_comparison_op(ParseState *pstate, List *opname, List *largs, List *rargs, int location)
static Node * transformAExprOp(ParseState *pstate, A_Expr *a)
static Node * transformJsonArrayAgg(ParseState *pstate, JsonArrayAgg *agg)
static Node * makeCaseTestExpr(Node *expr)
static Node * transformArrayExpr(ParseState *pstate, A_ArrayExpr *a, Oid array_type, Oid element_type, int32 typmod)
static Node * transformMultiAssignRef(ParseState *pstate, MultiAssignRef *maref)
static Node * coerceJsonFuncExpr(ParseState *pstate, Node *expr, const JsonReturning *returning, bool report_error)
static Node * transformBooleanTest(ParseState *pstate, BooleanTest *b)
static Node * make_row_distinct_op(ParseState *pstate, List *opname, RowExpr *lrow, RowExpr *rrow, int location)
static Node * transformTypeCast(ParseState *pstate, TypeCast *tc)
static Node * transformParamRef(ParseState *pstate, ParamRef *pref)
static Node * transformCaseExpr(ParseState *pstate, CaseExpr *c)
static void transformJsonPassingArgs(ParseState *pstate, JsonFormatType format, List *args, List **passing_values, List **passing_names)
static Node * transformJsonValueExprExt(ParseState *pstate, JsonValueExpr *ve, JsonFormatType default_format, bool isarg, Oid targettype)
static Node * transformJsonParseExpr(ParseState *pstate, JsonParseExpr *expr)
static Node * transformIndirection(ParseState *pstate, A_Indirection *ind)
const char * ParseExprKindName(ParseExprKind exprKind)
static Node * transformJsonParseArg(ParseState *pstate, Node *jsexpr, JsonFormat *format, Oid *exprtype)
static Node * transformJsonSerializeExpr(ParseState *pstate, JsonSerializeExpr *expr)
static Node * transformRowExpr(ParseState *pstate, RowExpr *r, bool allowDefault)
static Node * transformXmlExpr(ParseState *pstate, XmlExpr *x)
static JsonExpr * transformJsonExprCommon(ParseState *pstate, JsonFuncExpr *func)
static Node * transformAExprBetween(ParseState *pstate, A_Expr *a)
static Node * transformWholeRowRef(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, int location)
static Const * getJsonEncodingConst(JsonFormat *format)
static Node * transformJsonFuncExpr(ParseState *pstate, JsonFuncExpr *p)
static Node * transformJsonAggConstructor(ParseState *pstate, JsonAggConstructor *agg_ctor, JsonReturning *returning, List *args, const char *aggfn, Oid aggtype, JsonConstructorType ctor_type, bool unique, bool absent_on_null)
static Node * transformJsonValueExprDefault(ParseState *pstate, JsonValueExpr *jve)
static Node * transformJsonObjectAgg(ParseState *pstate, JsonObjectAgg *agg)
static Node * transformAExprDistinct(ParseState *pstate, A_Expr *a)
Node * ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs, Node *last_srf, FuncCall *fn, bool proc_call, int location)
void free_parsestate(ParseState *pstate)
SubscriptingRef * transformContainerSubscripts(ParseState *pstate, Node *containerBase, Oid containerType, int32 containerTypMod, List *indirection, bool isAssignment)
int parser_errposition(ParseState *pstate, int location)
ParseState * make_parsestate(ParseState *parentParseState)
Const * make_const(ParseState *pstate, A_Const *aconst)
@ EXPR_KIND_EXECUTE_PARAMETER
@ EXPR_KIND_COLUMN_DEFAULT
@ EXPR_KIND_STATS_EXPRESSION
@ EXPR_KIND_INDEX_EXPRESSION
@ EXPR_KIND_PARTITION_BOUND
@ EXPR_KIND_FUNCTION_DEFAULT
@ EXPR_KIND_WINDOW_FRAME_RANGE
@ EXPR_KIND_FROM_SUBSELECT
@ EXPR_KIND_WINDOW_FRAME_GROUPS
@ EXPR_KIND_PARTITION_EXPRESSION
@ EXPR_KIND_INDEX_PREDICATE
@ EXPR_KIND_INSERT_TARGET
@ EXPR_KIND_ALTER_COL_TRANSFORM
@ EXPR_KIND_UPDATE_TARGET
@ EXPR_KIND_SELECT_TARGET
@ EXPR_KIND_GENERATED_COLUMN
@ EXPR_KIND_CALL_ARGUMENT
@ EXPR_KIND_FROM_FUNCTION
@ EXPR_KIND_UPDATE_SOURCE
@ EXPR_KIND_CHECK_CONSTRAINT
@ EXPR_KIND_WINDOW_PARTITION
@ EXPR_KIND_WINDOW_FRAME_ROWS
@ EXPR_KIND_VALUES_SINGLE
Expr * make_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree, Node *last_srf, int location)
Expr * make_scalar_array_op(ParseState *pstate, List *opname, bool useOr, Node *ltree, Node *rtree, int location)
RangeTblEntry * GetRTEByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
void errorMissingColumn(ParseState *pstate, const char *relname, const char *colname, int location)
void markVarForSelectPriv(ParseState *pstate, Var *var)
void errorMissingRTE(ParseState *pstate, RangeVar *relation)
Node * scanNSItemForColumn(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, const char *colname, int location)
ParseNamespaceItem * refnameNamespaceItem(ParseState *pstate, const char *schemaname, const char *refname, int location, int *sublevels_up)
Node * colNameToVar(ParseState *pstate, const char *colname, bool localonly, int location)
void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up, int location, bool include_dropped, List **colnames, List **colvars)
List * transformExpressionList(ParseState *pstate, List *exprlist, ParseExprKind exprKind, bool allowDefault)
char * FigureColname(Node *node)
Oid LookupCollation(ParseState *pstate, List *collnames, int location)
void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
#define ISCOMPLEX(typeid)
Query * parse_sub_analyze(Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
Query * transformStmt(ParseState *pstate, Node *parseTree)
#define lfirst_node(type, lc)
static int list_length(const List *l)
#define forboth(cell1, list1, cell2, list2)
static void * list_nth(const List *list, int n)
#define list_make2(x1, x2)
static void output(uint64 loop_count)
void check_stack_depth(void)
#define CStringGetDatum(X)