71 bool isTopLevel,
List **targetlist);
88#ifdef DEBUG_NODE_TESTS_ENABLED
89static bool test_raw_expression_coverage(
Node *node,
void *context);
106 const Oid *paramTypes,
int numParams,
113 Assert(sourceText != NULL);
128 (*post_parse_analyze_hook) (pstate, query, jstate);
146 Oid **paramTypes,
int *numParams,
153 Assert(sourceText != NULL);
170 (*post_parse_analyze_hook) (pstate, query, jstate);
188 void *parserSetupArg,
195 Assert(sourceText != NULL);
199 (*parserSetup) (pstate, parserSetupArg);
207 (*post_parse_analyze_hook) (pstate, query, jstate);
224 bool locked_from_parent,
225 bool resolve_unknowns)
268 stmt_len = ((
InsertStmt *) parseTree)->stmt_len;
273 stmt_len = ((
DeleteStmt *) parseTree)->stmt_len;
278 stmt_len = ((
UpdateStmt *) parseTree)->stmt_len;
283 stmt_len = ((
MergeStmt *) parseTree)->stmt_len;
288 stmt_len = ((
SelectStmt *) parseTree)->stmt_len;
303 qry->stmt_len = stmt_len;
316 Assert(qry->stmt_len >= 0);
363 if (
stmt->intoClause)
367 ctas->
query = parseTree;
377 stmt->intoClause = NULL;
379 parseTree = (
Node *) ctas;
395#ifdef DEBUG_NODE_TESTS_ENABLED
403 if (Debug_raw_expression_coverage_test)
412 (void) test_raw_expression_coverage(parseTree, NULL);
471 case T_DeclareCursorStmt:
481 case T_CreateTableAsStmt:
505 result->canSetTag =
true;
549 case T_DeclareCursorStmt:
551 case T_CreateTableAsStmt:
614 case T_DeclareCursorStmt:
616 case T_CreateTableAsStmt:
642 if (
stmt->withClause)
644 qry->hasRecursive =
stmt->withClause->recursive;
710 bool isGeneralSelect;
712 List *sub_rteperminfos;
721 bool isOnConflictUpdate;
731 if (
stmt->withClause)
733 qry->hasRecursive =
stmt->withClause->recursive;
738 qry->override =
stmt->override;
740 isOnConflictUpdate = (
stmt->onConflictClause &&
752 isGeneralSelect = (selectStmt && (selectStmt->
valuesLists ==
NIL ||
780 sub_rteperminfos =
NIL;
791 if (isOnConflictUpdate)
794 false,
false, targetPerms);
803 if (selectStmt == NULL)
812 else if (isGeneralSelect)
852 elog(
ERROR,
"unexpected non-SELECT command in INSERT ... SELECT");
898 exprList =
lappend(exprList, expr);
919 int sublist_length = -1;
920 bool lateral =
false;
922 Assert(selectStmt->intoClause == NULL);
924 foreach(lc, selectStmt->valuesLists)
940 if (sublist_length < 0)
948 (
errcode(ERRCODE_SYNTAX_ERROR),
949 errmsg(
"VALUES lists must all be the same length"),
983 exprsLists =
lappend(exprsLists, sublist);
1016 coltypes, coltypmods, colcollations,
1017 NULL, lateral,
true);
1041 List *valuesLists = selectStmt->valuesLists;
1044 Assert(selectStmt->intoClause == NULL);
1066 perminfo = pstate->p_target_nsitem->p_perminfo;
1067 qry->targetList =
NIL;
1069 forthree(lc, exprList, icols, icolumns, attnos, attrnos)
1080 qry->targetList =
lappend(qry->targetList, tle);
1091 if (
stmt->onConflictClause ||
stmt->returningClause)
1093 pstate->p_namespace =
NIL;
1099 if (
stmt->onConflictClause)
1101 stmt->onConflictClause);
1104 if (
stmt->returningClause)
1109 qry->rtable = pstate->p_rtable;
1110 qry->rteperminfos = pstate->p_rteperminfos;
1111 qry->jointree =
makeFromExpr(pstate->p_joinlist, NULL);
1113 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
1114 qry->hasSubLinks = pstate->p_hasSubLinks;
1134 bool strip_indirection)
1150 (
errcode(ERRCODE_SYNTAX_ERROR),
1151 errmsg(
"INSERT has more expressions than target columns"),
1155 if (stmtcols !=
NIL &&
1168 (
errcode(ERRCODE_SYNTAX_ERROR),
1169 errmsg(
"INSERT has more target columns than expressions"),
1173 errhint(
"The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?") : 0),
1183 forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
1196 if (strip_indirection)
1205 Expr *subexpr = expr;
1231 result =
lappend(result, expr);
1248 Oid arbiterConstraint;
1250 Node *onConflictWhere = NULL;
1251 int exclRelIndex = 0;
1271 exclRte = exclNSItem->
p_rte;
1279 exclRte->relkind = RELKIND_COMPOSITE_TYPE;
1288 &arbiterWhere, &arbiterConstraint);
1366 if (attr->attisdropped)
1377 var =
makeVar(exclRelIndex, attno + 1,
1378 attr->atttypid, attr->atttypmod,
1400 targetrel->
rd_rel->reltype,
1430 if (
attnum > 0 && var->vartype == RECORDOID)
1441 if (ste == NULL || ste->resjunk)
1470 if (
stmt->withClause)
1472 qry->hasRecursive =
stmt->withClause->recursive;
1478 if (
stmt->intoClause)
1480 (
errcode(ERRCODE_SYNTAX_ERROR),
1481 errmsg(
"SELECT ... INTO is not allowed here"),
1530 if (
stmt->distinctClause ==
NIL)
1533 qry->hasDistinctOn =
false;
1542 qry->hasDistinctOn =
false;
1548 stmt->distinctClause,
1551 qry->hasDistinctOn =
true;
1581 foreach(l,
stmt->lockingClause)
1611 List **colexprs = NULL;
1612 int sublist_length = -1;
1613 bool lateral =
false;
1633 if (
stmt->withClause)
1635 qry->hasRecursive =
stmt->withClause->recursive;
1647 foreach(lc,
stmt->valuesLists)
1663 if (sublist_length < 0)
1673 (
errcode(ERRCODE_SYNTAX_ERROR),
1674 errmsg(
"VALUES lists must all be the same length"),
1681 foreach(lc2, sublist)
1685 colexprs[
i] =
lappend(colexprs[
i], col);
1710 for (
i = 0;
i < sublist_length;
i++)
1718 foreach(lc, colexprs[
i])
1731 colcollations =
lappend_oid(colcollations, colcoll);
1737 for (
i = 0;
i < sublist_length;
i++)
1739 forboth(lc, colexprs[
i], lc2, exprsLists)
1744 sublist =
lappend(sublist, col);
1764 coltypes, coltypmods, colcollations,
1765 NULL, lateral,
true);
1792 if (
stmt->lockingClause)
1794 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1797 errmsg(
"%s cannot be applied to VALUES",
1828 Query *leftmostQuery;
1833 List *lockingClause;
1844 int sv_rtable_length;
1860 leftmostSelect =
stmt->larg;
1861 while (leftmostSelect && leftmostSelect->
op !=
SETOP_NONE)
1862 leftmostSelect = leftmostSelect->
larg;
1864 leftmostSelect->
larg == NULL);
1867 (
errcode(ERRCODE_SYNTAX_ERROR),
1868 errmsg(
"SELECT ... INTO is not allowed here"),
1877 sortClause =
stmt->sortClause;
1878 limitOffset =
stmt->limitOffset;
1879 limitCount =
stmt->limitCount;
1880 lockingClause =
stmt->lockingClause;
1881 withClause =
stmt->withClause;
1884 stmt->limitOffset = NULL;
1885 stmt->limitCount = NULL;
1887 stmt->withClause = NULL;
1892 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1895 errmsg(
"%s is not allowed with UNION/INTERSECT/EXCEPT",
1897 linitial(lockingClause))->strength))));
1902 qry->hasRecursive = withClause->
recursive;
1918 node = sostmt->
larg;
1924 Assert(leftmostQuery != NULL);
1944 forfour(lct, sostmt->colTypes,
1945 lcm, sostmt->colTypmods,
1946 lcc, sostmt->colCollations,
1957 Assert(!lefttle->resjunk);
1958 colName =
pstrdup(lefttle->resname);
1971 targetvars =
lappend(targetvars, var);
1973 sortnscolumns[sortcolindex].
p_varno = leftmostRTI;
1975 sortnscolumns[sortcolindex].
p_vartype = colType;
1976 sortnscolumns[sortcolindex].
p_vartypmod = colTypmod;
1977 sortnscolumns[sortcolindex].
p_varcollid = colCollation;
1978 sortnscolumns[sortcolindex].
p_varnosyn = leftmostRTI;
2034 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2035 errmsg(
"invalid UNION/INTERSECT/EXCEPT ORDER BY clause"),
2036 errdetail(
"Only result column names can be used, not expressions or functions."),
2037 errhint(
"Add the expression/function to every SELECT, or move the UNION into a FROM clause."),
2058 foreach(l, lockingClause)
2090 &sortop, &eqop, NULL,
2099 if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
2108 grpcl->hashable = hashable;
2129 bool isTopLevel,
List **targetlist)
2141 if (
stmt->intoClause)
2143 (
errcode(ERRCODE_SYNTAX_ERROR),
2144 errmsg(
"INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT"),
2149 if (
stmt->lockingClause)
2151 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2154 errmsg(
"%s is not allowed with UNION/INTERSECT/EXCEPT",
2172 if (
stmt->sortClause ||
stmt->limitOffset ||
stmt->limitCount ||
2173 stmt->lockingClause ||
stmt->withClause)
2183 char selectName[32];
2203 NULL,
false,
false);
2215 (
errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2216 errmsg(
"UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
2232 *targetlist =
lappend(*targetlist, tle);
2239 snprintf(selectName,
sizeof(selectName),
"*SELECT* %d",
2252 return (
Node *) rtr;
2262 const char *context;
2286 if (isTopLevel && recursive)
2302 (
errcode(ERRCODE_SYNTAX_ERROR),
2303 errmsg(
"each %s query must have the same number of columns",
2311 op->colTypmods =
NIL;
2312 op->colCollations =
NIL;
2313 op->groupClauses =
NIL;
2314 forboth(ltl, ltargetlist, rtl, rtargetlist)
2362 if (lcoltype != UNKNOWNOID)
2364 rescoltype, context);
2369 rescoltype, context);
2373 if (rcoltype != UNKNOWNOID)
2375 rescoltype, context);
2380 rescoltype, context);
2402 op->colTypes =
lappend_oid(op->colTypes, rescoltype);
2403 op->colTypmods =
lappend_int(op->colTypmods, rescoltypmod);
2404 op->colCollations =
lappend_oid(op->colCollations, rescolcoll);
2422 op->groupClauses =
lappend(op->groupClauses,
2438 rescolnode->
typeId = rescoltype;
2439 rescolnode->typeMod = rescoltypmod;
2440 rescolnode->collation = rescolcoll;
2441 rescolnode->
location = bestlocation;
2446 *targetlist =
lappend(*targetlist, restle);
2463 Query *leftmostQuery;
2478 Assert(leftmostQuery != NULL);
2494 Assert(!lefttle->resjunk);
2495 colName =
pstrdup(lefttle->resname);
2500 targetList =
lappend(targetList, tle);
2518 qry->isReturn =
true;
2554 if (
stmt->withClause)
2556 qry->hasRecursive =
stmt->withClause->recursive;
2562 stmt->relation->inh,
2643 tle->resname = NULL;
2646 if (orig_tl == NULL)
2647 elog(
ERROR,
"UPDATE target count mismatch --- internal error");
2651 origTarget->
name,
true);
2654 (
errcode(ERRCODE_UNDEFINED_COLUMN),
2655 errmsg(
"column \"%s\" of relation \"%s\" does not exist",
2660 errhint(
"SET target columns cannot be qualified with the relation name.") : 0,
2672 orig_tl =
lnext(origTlist, orig_tl);
2674 if (orig_tl != NULL)
2675 elog(
ERROR,
"UPDATE target count mismatch --- internal error");
2704 for (
int i = 0;
i < numattrs;
i++)
2705 nscolumns[
i].p_varreturningtype = returning_type;
2730 int save_next_resno;
2732 if (returningClause == NULL)
2744 if (qry->returningOldAlias != NULL)
2746 errcode(ERRCODE_SYNTAX_ERROR),
2748 errmsg(
"%s cannot be specified multiple times",
"OLD"),
2750 qry->returningOldAlias =
option->value;
2754 if (qry->returningNewAlias != NULL)
2756 errcode(ERRCODE_SYNTAX_ERROR),
2758 errmsg(
"%s cannot be specified multiple times",
"NEW"),
2760 qry->returningNewAlias =
option->value;
2769 errcode(ERRCODE_DUPLICATE_ALIAS),
2770 errmsg(
"table name \"%s\" specified more than once",
2783 if (qry->returningOldAlias == NULL &&
2786 qry->returningOldAlias =
"old";
2789 if (qry->returningNewAlias == NULL &&
2792 qry->returningNewAlias =
"new";
2806 returningClause->
exprs,
2817 (
errcode(ERRCODE_SYNTAX_ERROR),
2818 errmsg(
"RETURNING must have at least one column"),
2851 List *indirection =
stmt->indirection;
2852 int nnames =
stmt->nnames;
2857 Oid targetcollation;
2875 while (--nnames > 0 && indirection !=
NIL)
2880 elog(
ERROR,
"invalid name count in PLAssignStmt");
2919 (
errcode(ERRCODE_SYNTAX_ERROR),
2921 "assignment source returned %d columns",
2951 else if (targettype != type_id &&
2952 (targettype == RECORDOID ||
ISCOMPLEX(targettype)) &&
2953 (type_id == RECORDOID ||
ISCOMPLEX(type_id)))
2973 targettype, targettypmod,
2978 if (tle->
expr == NULL)
2980 (
errcode(ERRCODE_DATATYPE_MISMATCH),
2981 errmsg(
"variable \"%s\" is of type %s"
2982 " but expression is of type %s",
2986 errhint(
"You will need to rewrite or cast the expression."),
3025 qry->hasDistinctOn =
false;
3034 qry->hasDistinctOn =
false;
3043 qry->hasDistinctOn =
true;
3104 (
errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3106 errmsg(
"cannot specify both %s and %s",
3107 "SCROLL",
"NO SCROLL")));
3112 (
errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3114 errmsg(
"cannot specify both %s and %s",
3115 "ASENSITIVE",
"INSENSITIVE")));
3124 elog(
ERROR,
"unexpected non-SELECT command in DECLARE CURSOR");
3131 if (query->hasModifyingCTE)
3133 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3134 errmsg(
"DECLARE CURSOR must not contain data-modifying statements in WITH")));
3139 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3142 errmsg(
"DECLARE CURSOR WITH HOLD ... %s is not supported",
3145 errdetail(
"Holdable cursors must be READ ONLY.")));
3150 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3153 errmsg(
"DECLARE SCROLL CURSOR ... %s is not supported",
3156 errdetail(
"Scrollable cursors must be READ ONLY.")));
3161 (
errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3164 errmsg(
"DECLARE INSENSITIVE CURSOR ... %s is not valid",
3167 errdetail(
"Insensitive cursors must be READ ONLY.")));
3192 bool generic_plan =
false;
3193 Oid *paramTypes = NULL;
3205 foreach(lc,
stmt->options)
3209 if (strcmp(opt->
defname,
"generic_plan") == 0)
3258 if (query->hasModifyingCTE)
3260 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3261 errmsg(
"materialized views must not use data-modifying statements in WITH")));
3270 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3271 errmsg(
"materialized views must not use temporary tables or views")));
3280 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3281 errmsg(
"materialized views may not be defined using bound parameters")));
3290 if (
stmt->into->rel->relpersistence == RELPERSISTENCE_UNLOGGED)
3292 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3293 errmsg(
"materialized views cannot be unlogged")));
3333 foreach(lc,
stmt->funccall->args)
3341 stmt->funccall->funcname,
3346 stmt->funccall->location);
3364 fexpr->funcresulttype,
3369 Anum_pg_proc_proargmodes,
3389 elog(
ERROR,
"proargmodes is not a 1-D char array of length %d or it contains nulls",
3395 foreach(lc, fexpr->
args)
3399 switch (argmodes[
i])
3402 case PROARGMODE_VARIADIC:
3405 case PROARGMODE_OUT:
3406 outargs =
lappend(outargs, n);
3408 case PROARGMODE_INOUT:
3414 elog(
ERROR,
"invalid argmode %c for procedure",
3420 fexpr->
args = inargs;
3423 stmt->funcexpr = fexpr;
3424 stmt->outargs = outargs;
3449 return "FOR KEY SHARE";
3453 return "FOR NO KEY UPDATE";
3455 return "FOR UPDATE";
3472 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3475 errmsg(
"%s is not allowed with UNION/INTERSECT/EXCEPT",
3479 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3482 errmsg(
"%s is not allowed with DISTINCT clause",
3486 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3489 errmsg(
"%s is not allowed with GROUP BY clause",
3493 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3496 errmsg(
"%s is not allowed with HAVING clause",
3500 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3503 errmsg(
"%s is not allowed with aggregate functions",
3505 if (qry->hasWindowFuncs)
3507 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3510 errmsg(
"%s is not allowed with window functions",
3512 if (qry->hasTargetSRFs)
3514 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3517 errmsg(
"%s is not allowed with set-returning functions in the target list",
3547 if (lockedRels ==
NIL)
3606 foreach(l, lockedRels)
3613 (
errcode(ERRCODE_SYNTAX_ERROR),
3616 errmsg(
"%s must specify unqualified relation names",
3624 char *rtename = rte->eref->aliasname;
3639 if (rte->alias == NULL)
3643 if (rte->join_using_alias == NULL)
3645 rtename = rte->join_using_alias->aliasname;
3652 if (strcmp(rtename, thisrel->
relname) == 0)
3677 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3680 errmsg(
"%s cannot be applied to a join",
3686 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3689 errmsg(
"%s cannot be applied to a function",
3695 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3698 errmsg(
"%s cannot be applied to a table function",
3704 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3707 errmsg(
"%s cannot be applied to VALUES",
3713 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3716 errmsg(
"%s cannot be applied to a WITH query",
3722 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3725 errmsg(
"%s cannot be applied to a named tuplestore",
3733 elog(
ERROR,
"unrecognized RTE type: %d",
3745 errmsg(
"relation \"%s\" in %s clause not found in FROM clause",
3767 qry->hasForUpdate =
true;
3806#ifdef DEBUG_NODE_TESTS_ENABLED
3816test_raw_expression_coverage(
Node *node,
void *context)
3821 test_raw_expression_coverage,
void(* post_parse_analyze_hook_type)(ParseState *pstate, Query *query, JumbleState *jstate)
#define DatumGetArrayTypeP(X)
#define InvalidAttrNumber
void pgstat_report_query_id(uint64 query_id, bool force)
Bitmapset * bms_add_member(Bitmapset *a, int x)
List * expand_function_arguments(List *args, bool include_out_arguments, Oid result_type, HeapTuple func_tuple)
bool defGetBoolean(DefElem *def)
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
Assert(PointerIsAligned(start, uint64))
#define HeapTupleIsValid(tuple)
if(TABLE==NULL||TABLE_index==NULL)
List * lappend(List *list, void *datum)
List * list_delete_first(List *list)
List * list_copy(const List *oldlist)
List * lappend_int(List *list, int datum)
List * lappend_oid(List *list, Oid datum)
List * list_delete_last(List *list)
void list_free(List *list)
List * list_truncate(List *list, int new_size)
Alias * makeAlias(const char *aliasname, List *colnames)
Var * makeVarFromTargetEntry(int varno, TargetEntry *tle)
FromExpr * makeFromExpr(List *fromlist, Node *quals)
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
char * pstrdup(const char *in)
void * palloc0(Size size)
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
Oid exprCollation(const Node *expr)
int exprLocation(const Node *expr)
#define raw_expression_tree_walker(n, w, c)
#define IsA(nodeptr, _type_)
#define castNode(_type_, nodeptr)
void(* ParserSetupHook)(struct ParseState *pstate, void *arg)
void parseCheckAggregates(ParseState *pstate, Query *qry)
List * transformGroupClause(ParseState *pstate, List *grouplist, List **groupingSets, List **targetlist, List *sortClause, ParseExprKind exprKind, bool useSQL99)
Node * transformWhereClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName)
List * transformSortClause(ParseState *pstate, List *orderlist, List **targetlist, ParseExprKind exprKind, bool useSQL99)
List * transformDistinctOnClause(ParseState *pstate, List *distinctlist, List **targetlist, List *sortClause)
List * transformWindowDefinitions(ParseState *pstate, List *windowdefs, List **targetlist)
void transformFromClause(ParseState *pstate, List *frmList)
List * transformDistinctClause(ParseState *pstate, List **targetlist, List *sortClause, bool is_agg)
Node * transformLimitClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName, LimitOption limitOption)
void transformOnConflictArbiter(ParseState *pstate, OnConflictClause *onConflictClause, List **arbiterExpr, Node **arbiterWhere, Oid *constraint)
int setTargetTable(ParseState *pstate, RangeVar *relation, bool inh, bool alsoSource, AclMode requiredPerms)
Node * coerce_to_common_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *context)
int32 select_common_typmod(ParseState *pstate, List *exprs, Oid common_type)
Oid select_common_type(ParseState *pstate, List *exprs, const char *context, Node **which_expr)
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
void assign_list_collations(ParseState *pstate, List *exprs)
Oid select_common_collation(ParseState *pstate, List *exprs, bool none_ok)
void assign_query_collations(ParseState *pstate, Query *query)
void assign_expr_collations(ParseState *pstate, Node *expr)
void analyzeCTETargetList(ParseState *pstate, CommonTableExpr *cte, List *tlist)
List * transformWithClause(ParseState *pstate, WithClause *withClause)
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Node * ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs, Node *last_srf, FuncCall *fn, bool proc_call, int location)
Query * transformMergeStmt(ParseState *pstate, MergeStmt *stmt)
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
void free_parsestate(ParseState *pstate)
int parser_errposition(ParseState *pstate, int location)
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
ParseState * make_parsestate(ParseState *parentParseState)
@ EXPR_KIND_INSERT_TARGET
@ EXPR_KIND_UPDATE_TARGET
@ EXPR_KIND_SELECT_TARGET
@ EXPR_KIND_CALL_ARGUMENT
@ EXPR_KIND_UPDATE_SOURCE
@ EXPR_KIND_VALUES_SINGLE
struct ParseNamespaceColumn ParseNamespaceColumn
void get_sort_group_operators(Oid argtype, bool needLT, bool needEQ, bool needGT, Oid *ltOpr, Oid *eqOpr, Oid *gtOpr, bool *isHashable)
void check_variable_parameters(ParseState *pstate, Query *query)
bool query_contains_extern_params(Query *query)
void setup_parse_variable_parameters(ParseState *pstate, Oid **paramTypes, int *numParams)
void setup_parse_fixed_parameters(ParseState *pstate, const Oid *paramTypes, int numParams)
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
RowMarkClause * get_parse_rowmark(Query *qry, Index rtindex)
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
List * expandNSItemVars(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, int location, List **colnames)
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
ParseNamespaceItem * addRangeTableEntryForSubquery(ParseState *pstate, Query *subquery, Alias *alias, bool lateral, bool inFromCl)
ParseNamespaceItem * addRangeTableEntryForJoin(ParseState *pstate, List *colnames, ParseNamespaceColumn *nscolumns, JoinType jointype, int nummergedcols, List *aliasvars, List *leftcols, List *rightcols, Alias *join_using_alias, Alias *alias, bool inFromCl)
List * expandNSItemAttrs(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, bool require_col_privs, int location)
bool isQueryUsingTempRelation(Query *query)
ParseNamespaceItem * refnameNamespaceItem(ParseState *pstate, const char *schemaname, const char *refname, int location, int *sublevels_up)
RangeTblEntry * GetRTEByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
ParseNamespaceItem * addRangeTableEntryForValues(ParseState *pstate, List *exprs, List *coltypes, List *coltypmods, List *colcollations, Alias *alias, bool lateral, bool inFromCl)
Expr * transformAssignedExpr(ParseState *pstate, Expr *expr, ParseExprKind exprKind, const char *colname, int attrno, List *indirection, int location)
List * transformExpressionList(ParseState *pstate, List *exprlist, ParseExprKind exprKind, bool allowDefault)
Node * transformAssignmentIndirection(ParseState *pstate, Node *basenode, const char *targetName, bool targetIsSubscripting, Oid targetTypeId, int32 targetTypMod, Oid targetCollation, List *indirection, ListCell *indirection_cell, Node *rhs, CoercionContext ccontext, int location)
void updateTargetListEntry(ParseState *pstate, TargetEntry *tle, char *colname, int attrno, List *indirection, int location)
List * transformTargetList(ParseState *pstate, List *targetlist, ParseExprKind exprKind)
void resolveTargetListUnknowns(ParseState *pstate, List *targetlist)
void markTargetListOrigins(ParseState *pstate, List *targetlist)
List * checkInsertTargets(ParseState *pstate, List *cols, List **attrnos)
#define ISCOMPLEX(typeid)
#define CURSOR_OPT_INSENSITIVE
#define CURSOR_OPT_SCROLL
#define ACL_SELECT_FOR_UPDATE
#define CURSOR_OPT_ASENSITIVE
#define CURSOR_OPT_NO_SCROLL
static OnConflictExpr * transformOnConflictClause(ParseState *pstate, OnConflictClause *onConflictClause)
static Query * transformOptionalSelectInto(ParseState *pstate, Node *parseTree)
static void transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc, bool pushedDown)
static void setQueryLocationAndLength(ParseState *pstate, Query *qry, Node *parseTree)
static Query * transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
void CheckSelectLocking(Query *qry, LockClauseStrength strength)
SortGroupClause * makeSortGroupClauseForSetOp(Oid rescoltype, bool require_hash)
static Node * transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, bool isTopLevel, List **targetlist)
Query * parse_analyze_withcb(RawStmt *parseTree, const char *sourceText, ParserSetupHook parserSetup, void *parserSetupArg, QueryEnvironment *queryEnv)
bool analyze_requires_snapshot(RawStmt *parseTree)
List * transformInsertRow(ParseState *pstate, List *exprlist, List *stmtcols, List *icolumns, List *attrnos, bool strip_indirection)
void applyLockingClause(Query *qry, Index rtindex, LockClauseStrength strength, LockWaitPolicy waitPolicy, bool pushedDown)
static void determineRecursiveColTypes(ParseState *pstate, Node *larg, List *nrtargetlist)
static Query * transformReturnStmt(ParseState *pstate, ReturnStmt *stmt)
static void addNSItemForReturning(ParseState *pstate, const char *aliasname, VarReturningType returning_type)
void transformReturningClause(ParseState *pstate, Query *qry, ReturningClause *returningClause, ParseExprKind exprKind)
static Query * transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt)
static Query * transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt)
post_parse_analyze_hook_type post_parse_analyze_hook
static Query * transformCallStmt(ParseState *pstate, CallStmt *stmt)
List * transformUpdateTargetList(ParseState *pstate, List *origTlist)
static Query * transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
bool query_requires_rewrite_plan(Query *query)
Query * transformTopLevelStmt(ParseState *pstate, RawStmt *parseTree)
const char * LCS_asString(LockClauseStrength strength)
Query * parse_analyze_fixedparams(RawStmt *parseTree, const char *sourceText, const Oid *paramTypes, int numParams, QueryEnvironment *queryEnv)
static Query * transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
static Query * transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
Query * parse_sub_analyze(Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
static Query * transformExplainStmt(ParseState *pstate, ExplainStmt *stmt)
List * BuildOnConflictExcludedTargetlist(Relation targetrel, Index exclRelIndex)
static int count_rowexpr_columns(ParseState *pstate, Node *expr)
Query * parse_analyze_varparams(RawStmt *parseTree, const char *sourceText, Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv)
bool stmt_requires_parse_analysis(RawStmt *parseTree)
static Query * transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
static Query * transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
static Query * transformValuesClause(ParseState *pstate, SelectStmt *stmt)
Query * transformStmt(ParseState *pstate, Node *parseTree)
#define rt_fetch(rangetable_index, rangetable)
FormData_pg_attribute * Form_pg_attribute
#define lfirst_node(type, lc)
static int list_length(const List *l)
#define linitial_node(type, l)
#define forboth(cell1, list1, cell2, list2)
#define forthree(cell1, list1, cell2, list2, cell3, list3)
static void * list_nth(const List *list, int n)
#define foreach_node(type, var, lst)
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
static ListCell * list_head(const List *l)
static ListCell * lnext(const List *l, const ListCell *c)
#define list_make2(x1, x2)
#define ERRCODE_UNDEFINED_TABLE
static Datum ObjectIdGetDatum(Oid X)
static bool IsQueryIdEnabled(void)
JumbleState * JumbleQuery(Query *query)
#define RelationGetNumberOfAttributes(relation)
#define RelationGetRelationName(relation)
void check_stack_depth(void)
LockClauseStrength strength
LockWaitPolicy waitPolicy
ParseNamespaceColumn * p_nscolumns
RTEPermissionInfo * p_perminfo
VarReturningType p_returning_type
ParseNamespaceItem * p_target_nsitem
ParseExprKind p_expr_kind
bool p_locked_from_parent
ParseParamRefHook p_paramref_hook
QueryEnvironment * p_queryEnv
const char * p_sourcetext
Relation p_target_relation
CommonTableExpr * p_parent_cte
LockClauseStrength strength
LockWaitPolicy waitPolicy
#define FirstLowInvalidHeapAttributeNumber
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
String * makeString(char *str)
bool contain_vars_of_level(Node *node, int levelsup)
int locate_var_of_level(Node *node, int levelsup)