#include "postgres.h"#include "access/sysattr.h"#include "catalog/pg_proc.h"#include "catalog/pg_type.h"#include "commands/defrem.h"#include "miscadmin.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "nodes/queryjumble.h"#include "optimizer/optimizer.h"#include "parser/analyze.h"#include "parser/parse_agg.h"#include "parser/parse_clause.h"#include "parser/parse_coerce.h"#include "parser/parse_collate.h"#include "parser/parse_cte.h"#include "parser/parse_expr.h"#include "parser/parse_func.h"#include "parser/parse_merge.h"#include "parser/parse_oper.h"#include "parser/parse_param.h"#include "parser/parse_relation.h"#include "parser/parse_target.h"#include "parser/parse_type.h"#include "parser/parsetree.h"#include "utils/backend_status.h"#include "utils/builtins.h"#include "utils/guc.h"#include "utils/rel.h"#include "utils/syscache.h"
Include dependency graph for analyze.c:
Go to the source code of this file.
Variables | |
| post_parse_analyze_hook_type | post_parse_analyze_hook = NULL |
Function Documentation
◆ addNSItemForReturning()
|
static |
Definition at line 2651 of file analyze.c.
2653{
2654 List *colnames;
2655 int numattrs;
2656 ParseNamespaceColumn *nscolumns;
2657 ParseNamespaceItem *nsitem;
2658
2659 /* copy per-column data from the target relation */
2661 numattrs = list_length(colnames);
2662
2663 nscolumns = (ParseNamespaceColumn *)
2665
2668
2669 /* mark all columns as returning OLD/NEW */
2671 nscolumns[i].p_varreturningtype = returning_type;
2672
2673 /* build the nsitem, copying most fields from the target relation */
2679 nsitem->p_nscolumns = nscolumns;
2680 nsitem->p_returning_type = returning_type;
2681
2682 /* add it to the query namespace as a table-only item */
2684}
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
Definition: parse_relation.c:2706
Definition: pg_list.h:54
Definition: parse_node.h:345
Definition: parse_node.h:309
References addNSItemToQuery(), i, list_length(), makeAlias(), ParseNamespaceItem::p_names, ParseNamespaceItem::p_nscolumns, ParseNamespaceItem::p_perminfo, ParseNamespaceItem::p_returning_type, ParseNamespaceItem::p_rte, ParseNamespaceItem::p_rtindex, ParseState::p_target_nsitem, and palloc().
Referenced by transformReturningClause().
◆ analyze_requires_snapshot()
| bool analyze_requires_snapshot | ( | RawStmt * | parseTree | ) |
Definition at line 576 of file analyze.c.
577{
578 /*
579 * Currently, this should return true in exactly the same cases that
580 * stmt_requires_parse_analysis() does, so we just invoke that function
581 * rather than duplicating it. We keep the two entry points separate for
582 * clarity of callers, since from the callers' standpoint these are
583 * different conditions.
584 *
585 * While there may someday be a statement type for which transformStmt()
586 * does something nontrivial and yet no snapshot is needed for that
587 * processing, it seems likely that making such a choice would be fragile.
588 * If you want to install an exception, document the reasoning for it in a
589 * comment.
590 */
592}
bool stmt_requires_parse_analysis(RawStmt *parseTree)
Definition: analyze.c:532
References stmt_requires_parse_analysis().
Referenced by BuildCachedPlan(), exec_bind_message(), exec_parse_message(), and exec_simple_query().
◆ applyLockingClause()
| void applyLockingClause | ( | Query * | qry, |
| Index | rtindex, | ||
| LockClauseStrength | strength, | ||
| LockWaitPolicy | waitPolicy, | ||
| bool | pushedDown | ||
| ) |
Definition at line 3723 of file analyze.c.
3726{
3727 RowMarkClause *rc;
3728
3730
3731 /* If it's an explicit clause, make sure hasForUpdate gets set */
3732 if (!pushedDown)
3733 qry->hasForUpdate = true;
3734
3735 /* Check for pre-existing entry for same rtindex */
3737 {
3738 /*
3739 * If the same RTE is specified with more than one locking strength,
3740 * use the strongest. (Reasonable, since you can't take both a shared
3741 * and exclusive lock at the same time; it'll end up being exclusive
3742 * anyway.)
3743 *
3744 * Similarly, if the same RTE is specified with more than one lock
3745 * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
3746 * turn wins over waiting for the lock (the default). This is a bit
3747 * more debatable but raising an error doesn't seem helpful. (Consider
3748 * for instance SELECT FOR UPDATE NOWAIT from a view that internally
3749 * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP
3750 * LOCKED is reasonable since the former throws an error in case of
3751 * coming across a locked tuple, which may be undesirable in some
3752 * cases but it seems better than silently returning inconsistent
3753 * results.
3754 *
3755 * And of course pushedDown becomes false if any clause is explicit.
3756 */
3759 rc->pushedDown &= pushedDown;
3760 return;
3761 }
3762
3763 /* Make a new RowMarkClause */
3765 rc->rti = rtindex;
3766 rc->strength = strength;
3767 rc->waitPolicy = waitPolicy;
3768 rc->pushedDown = pushedDown;
3770}
RowMarkClause * get_parse_rowmark(Query *qry, Index rtindex)
Definition: parse_relation.c:3561
Definition: parsenodes.h:1586
References Assert, get_parse_rowmark(), lappend(), LCS_NONE, makeNode, Max, RowMarkClause::pushedDown, Query::rowMarks, RowMarkClause::rti, RowMarkClause::strength, and RowMarkClause::waitPolicy.
Referenced by markQueryForLocking(), and transformLockingClause().
◆ BuildOnConflictExcludedTargetlist()
Definition at line 1315 of file analyze.c.
1317{
1319 int attno;
1320 Var *var;
1321 TargetEntry *te;
1322
1323 /*
1324 * Note that resnos of the tlist must correspond to attnos of the
1325 * underlying relation, hence we need entries for dropped columns too.
1326 */
1328 {
1331
1332 if (attr->attisdropped)
1333 {
1334 /*
1335 * can't use atttypid here, but it doesn't really matter what type
1336 * the Const claims to be.
1337 */
1339 name = NULL;
1340 }
1341 else
1342 {
1343 var = makeVar(exclRelIndex, attno + 1,
1344 attr->atttypid, attr->atttypmod,
1345 attr->attcollation,
1346 0);
1348 }
1349
1351 attno + 1,
1352 name,
1353 false);
1354
1355 result = lappend(result, te);
1356 }
1357
1358 /*
1359 * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like
1360 * the other entries in the EXCLUDED tlist, its resno must match the Var's
1361 * varattno, else the wrong things happen while resolving references in
1362 * setrefs.c. This is against normal conventions for targetlists, but
1363 * it's okay since we don't use this as a real tlist.
1364 */
1366 targetrel->rd_rel->reltype,
1367 -1, InvalidOid, 0);
1369 result = lappend(result, te);
1370
1371 return result;
1372}
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition: makefuncs.c:66
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition: makefuncs.c:341
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:242
Definition: primnodes.h:188
Definition: primnodes.h:2242
Definition: primnodes.h:261
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:153
References InvalidAttrNumber, InvalidOid, lappend(), makeNullConst(), makeTargetEntry(), makeVar(), name, NameStr, NIL, pstrdup(), RelationData::rd_att, RelationData::rd_rel, RelationGetNumberOfAttributes, and TupleDescAttr().
Referenced by rewriteTargetView(), and transformOnConflictClause().
◆ CheckSelectLocking()
| void CheckSelectLocking | ( | Query * | qry, |
| LockClauseStrength | strength | ||
| ) |
Definition at line 3432 of file analyze.c.
3433{
3435
3438 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3439 /*------
3440 translator: %s is a SQL row locking clause such as FOR UPDATE */
3442 LCS_asString(strength))));
3445 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3446 /*------
3447 translator: %s is a SQL row locking clause such as FOR UPDATE */
3449 LCS_asString(strength))));
3452 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3453 /*------
3454 translator: %s is a SQL row locking clause such as FOR UPDATE */
3456 LCS_asString(strength))));
3459 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3460 /*------
3461 translator: %s is a SQL row locking clause such as FOR UPDATE */
3463 LCS_asString(strength))));
3464 if (qry->hasAggs)
3466 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3467 /*------
3468 translator: %s is a SQL row locking clause such as FOR UPDATE */
3470 LCS_asString(strength))));
3471 if (qry->hasWindowFuncs)
3473 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3474 /*------
3475 translator: %s is a SQL row locking clause such as FOR UPDATE */
3477 LCS_asString(strength))));
3478 if (qry->hasTargetSRFs)
3480 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3481 /*------
3482 translator: %s is a SQL row locking clause such as FOR UPDATE */
3484 LCS_asString(strength))));
3485}
References Assert, Query::distinctClause, ereport, errcode(), errmsg(), ERROR, Query::groupClause, Query::groupingSets, Query::havingQual, LCS_asString(), LCS_NONE, NIL, and Query::setOperations.
Referenced by preprocess_rowmarks(), and transformLockingClause().
◆ count_rowexpr_columns()
|
static |
Definition at line 1385 of file analyze.c.
1386{
1387 if (expr == NULL)
1388 return -1;
1392 {
1395
1397 {
1398 RangeTblEntry *rte;
1399
1402 {
1403 /* Subselect-in-FROM: examine sub-select's output expr */
1405 attnum);
1406
1407 if (ste == NULL || ste->resjunk)
1408 return -1;
1412 }
1413 }
1414 }
1415 return -1;
1416}
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition: parse_relation.c:3541
RangeTblEntry * GetRTEByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
Definition: parse_relation.c:545
Definition: nodes.h:129
Definition: parsenodes.h:1041
Definition: primnodes.h:1425
References generate_unaccent_rules::args, attnum, TargetEntry::expr, get_tle_by_resno(), GetRTEByRangeTablePosn(), if(), IsA, list_length(), RTE_SUBQUERY, RangeTblEntry::rtekind, RangeTblEntry::subquery, Query::targetList, Var::varattno, Var::varlevelsup, and Var::varno.
Referenced by transformInsertRow().
◆ determineRecursiveColTypes()
|
static |
Definition at line 2425 of file analyze.c.
2426{
2427 Node *node;
2428 int leftmostRTI;
2429 Query *leftmostQuery;
2430 List *targetList;
2431 ListCell *left_tlist;
2432 ListCell *nrtl;
2433 int next_resno;
2434
2435 /*
2436 * Find leftmost leaf SELECT
2437 */
2438 node = larg;
2440 node = ((SetOperationStmt *) node)->larg;
2442 leftmostRTI = ((RangeTblRef *) node)->rtindex;
2444 Assert(leftmostQuery != NULL);
2445
2446 /*
2447 * Generate dummy targetlist using column names of leftmost select and
2448 * dummy result expressions of the non-recursive term.
2449 */
2450 targetList = NIL;
2451 next_resno = 1;
2452
2454 {
2457 char *colName;
2458 TargetEntry *tle;
2459
2460 Assert(!lefttle->resjunk);
2461 colName = pstrdup(lefttle->resname);
2463 next_resno++,
2464 colName,
2465 false);
2466 targetList = lappend(targetList, tle);
2467 }
2468
2469 /* Now build CTE's output column info using dummy targetlist */
2471}
void analyzeCTETargetList(ParseState *pstate, CommonTableExpr *cte, List *tlist)
Definition: parse_cte.c:570
Definition: parsenodes.h:118
Definition: primnodes.h:2299
Definition: parsenodes.h:2240
Definition: pg_list.h:46
References analyzeCTETargetList(), Assert, TargetEntry::expr, forboth, IsA, lappend(), lfirst, makeTargetEntry(), NIL, ParseState::p_parent_cte, ParseState::p_rtable, pstrdup(), rt_fetch, and Query::targetList.
Referenced by transformSetOperationTree().
◆ LCS_asString()
| const char * LCS_asString | ( | LockClauseStrength | strength | ) |
Definition at line 3407 of file analyze.c.
3408{
3409 switch (strength)
3410 {
3413 break;
3415 return "FOR KEY SHARE";
3417 return "FOR SHARE";
3419 return "FOR NO KEY UPDATE";
3421 return "FOR UPDATE";
3422 }
3423 return "FOR some"; /* shouldn't happen */
3424}
References Assert, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, and LCS_NONE.
Referenced by CheckSelectLocking(), grouping_planner(), make_outerjoininfo(), transformDeclareCursorStmt(), transformLockingClause(), transformSetOperationStmt(), transformSetOperationTree(), and transformValuesClause().
◆ makeSortGroupClauseForSetOp()
| SortGroupClause * makeSortGroupClauseForSetOp | ( | Oid | rescoltype, |
| bool | require_hash | ||
| ) |
Definition at line 2046 of file analyze.c.
2047{
2049 Oid sortop;
2050 Oid eqop;
2051 bool hashable;
2052
2053 /* determine the eqop and optional sortop */
2054 get_sort_group_operators(rescoltype,
2055 false, true, false,
2056 &sortop, &eqop, NULL,
2057 &hashable);
2058
2059 /*
2060 * The type cache doesn't believe that record is hashable (see
2061 * cache_record_field_properties()), but if the caller really needs hash
2062 * support, we can assume it does. Worst case, if any components of the
2063 * record don't support hashing, we will fail at execution.
2064 */
2065 if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
2066 hashable = true;
2067
2068 /* we don't have a tlist yet, so can't assign sortgrouprefs */
2069 grpcl->tleSortGroupRef = 0;
2070 grpcl->eqop = eqop;
2071 grpcl->sortop = sortop;
2074 grpcl->hashable = hashable;
2075
2076 return grpcl;
2077}
void get_sort_group_operators(Oid argtype, bool needLT, bool needEQ, bool needGT, Oid *ltOpr, Oid *eqOpr, Oid *gtOpr, bool *isHashable)
Definition: parse_oper.c:180
Definition: parsenodes.h:1445
References SortGroupClause::eqop, get_sort_group_operators(), makeNode, SortGroupClause::nulls_first, SortGroupClause::reverse_sort, SortGroupClause::sortop, and SortGroupClause::tleSortGroupRef.
Referenced by rewriteSearchAndCycle(), and transformSetOperationTree().
◆ parse_analyze_fixedparams()
| Query * parse_analyze_fixedparams | ( | RawStmt * | parseTree, |
| const char * | sourceText, | ||
| const Oid * | paramTypes, | ||
| int | numParams, | ||
| QueryEnvironment * | queryEnv | ||
| ) |
Definition at line 105 of file analyze.c.
108{
110 Query *query;
111 JumbleState *jstate = NULL;
112
114
115 pstate->p_sourcetext = sourceText;
116
117 if (numParams > 0)
118 setup_parse_fixed_parameters(pstate, paramTypes, numParams);
119
120 pstate->p_queryEnv = queryEnv;
121
122 query = transformTopLevelStmt(pstate, parseTree);
123
125 jstate = JumbleQuery(query);
126
128 (*post_parse_analyze_hook) (pstate, query, jstate);
129
130 free_parsestate(pstate);
131
133
134 return query;
135}
void pgstat_report_query_id(uint64 query_id, bool force)
Definition: backend_status.c:615
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:39
void setup_parse_fixed_parameters(ParseState *pstate, const Oid *paramTypes, int numParams)
Definition: parse_param.c:68
Query * transformTopLevelStmt(ParseState *pstate, RawStmt *parseTree)
Definition: analyze.c:332
Definition: queryjumble.h:33
Definition: parse_node.h:207
References Assert, free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, setup_parse_fixed_parameters(), and transformTopLevelStmt().
Referenced by DefineView(), and pg_analyze_and_rewrite_fixedparams().
◆ parse_analyze_varparams()
| Query * parse_analyze_varparams | ( | RawStmt * | parseTree, |
| const char * | sourceText, | ||
| Oid ** | paramTypes, | ||
| int * | numParams, | ||
| QueryEnvironment * | queryEnv | ||
| ) |
Definition at line 145 of file analyze.c.
148{
150 Query *query;
151 JumbleState *jstate = NULL;
152
154
155 pstate->p_sourcetext = sourceText;
156
157 setup_parse_variable_parameters(pstate, paramTypes, numParams);
158
159 pstate->p_queryEnv = queryEnv;
160
161 query = transformTopLevelStmt(pstate, parseTree);
162
163 /* make sure all is well with parameter types */
164 check_variable_parameters(pstate, query);
165
167 jstate = JumbleQuery(query);
168
170 (*post_parse_analyze_hook) (pstate, query, jstate);
171
172 free_parsestate(pstate);
173
175
176 return query;
177}
void check_variable_parameters(ParseState *pstate, Query *query)
Definition: parse_param.c:269
void setup_parse_variable_parameters(ParseState *pstate, Oid **paramTypes, int *numParams)
Definition: parse_param.c:84
References Assert, check_variable_parameters(), free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, setup_parse_variable_parameters(), and transformTopLevelStmt().
Referenced by pg_analyze_and_rewrite_varparams().
◆ parse_analyze_withcb()
| Query * parse_analyze_withcb | ( | RawStmt * | parseTree, |
| const char * | sourceText, | ||
| ParserSetupHook | parserSetup, | ||
| void * | parserSetupArg, | ||
| QueryEnvironment * | queryEnv | ||
| ) |
Definition at line 186 of file analyze.c.
190{
192 Query *query;
193 JumbleState *jstate = NULL;
194
196
197 pstate->p_sourcetext = sourceText;
198 pstate->p_queryEnv = queryEnv;
199 (*parserSetup) (pstate, parserSetupArg);
200
201 query = transformTopLevelStmt(pstate, parseTree);
202
204 jstate = JumbleQuery(query);
205
207 (*post_parse_analyze_hook) (pstate, query, jstate);
208
209 free_parsestate(pstate);
210
212
213 return query;
214}
References Assert, free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, and transformTopLevelStmt().
Referenced by pg_analyze_and_rewrite_withcb().
◆ parse_sub_analyze()
| Query * parse_sub_analyze | ( | Node * | parseTree, |
| ParseState * | parentParseState, | ||
| CommonTableExpr * | parentCTE, | ||
| bool | locked_from_parent, | ||
| bool | resolve_unknowns | ||
| ) |
Definition at line 222 of file analyze.c.
226{
228 Query *query;
229
230 pstate->p_parent_cte = parentCTE;
231 pstate->p_locked_from_parent = locked_from_parent;
232 pstate->p_resolve_unknowns = resolve_unknowns;
233
234 query = transformStmt(pstate, parseTree);
235
236 free_parsestate(pstate);
237
238 return query;
239}
References free_parsestate(), make_parsestate(), ParseState::p_locked_from_parent, ParseState::p_parent_cte, ParseState::p_resolve_unknowns, and transformStmt().
Referenced by analyzeCTE(), transformRangeSubselect(), transformSetOperationTree(), and transformSubLink().
◆ setQueryLocationAndLength()
|
static |
Definition at line 259 of file analyze.c.
260{
261 ParseLoc stmt_len = 0;
262
263 /*
264 * If there is no information about the top RawStmt's length, leave it at
265 * 0 to use the whole string.
266 */
268 return;
269
271 {
272 case T_InsertStmt:
274 stmt_len = ((InsertStmt *) parseTree)->stmt_len;
275 break;
276
277 case T_DeleteStmt:
279 stmt_len = ((DeleteStmt *) parseTree)->stmt_len;
280 break;
281
282 case T_UpdateStmt:
284 stmt_len = ((UpdateStmt *) parseTree)->stmt_len;
285 break;
286
287 case T_MergeStmt:
289 stmt_len = ((MergeStmt *) parseTree)->stmt_len;
290 break;
291
292 case T_SelectStmt:
294 stmt_len = ((SelectStmt *) parseTree)->stmt_len;
295 break;
296
297 case T_PLAssignStmt:
299 break;
300
301 default:
303 break;
304 }
305
306 if (stmt_len > 0)
307 {
308 /* Statement's length is known, use it */
309 qry->stmt_len = stmt_len;
310 }
311 else
312 {
313 /*
314 * Compute the statement's length from the statement's location and
315 * the RawStmt's length and location.
316 */
318 }
319
320 /* The calculated statement length should be calculated as positive. */
321 Assert(qry->stmt_len >= 0);
322}
Definition: parsenodes.h:2102
Definition: parsenodes.h:2084
Definition: parsenodes.h:2135
Definition: parsenodes.h:2279
Definition: parsenodes.h:2169
Definition: parsenodes.h:2118
References Assert, nodeTag, ParseState::p_stmt_len, ParseState::p_stmt_location, and Query::stmt_location.
Referenced by transformStmt().
◆ stmt_requires_parse_analysis()
| bool stmt_requires_parse_analysis | ( | RawStmt * | parseTree | ) |
Definition at line 532 of file analyze.c.
533{
534 bool result;
535
537 {
538 /*
539 * Optimizable statements
540 */
541 case T_InsertStmt:
542 case T_DeleteStmt:
543 case T_UpdateStmt:
544 case T_MergeStmt:
545 case T_SelectStmt:
546 case T_ReturnStmt:
547 case T_PLAssignStmt:
548 result = true;
549 break;
550
551 /*
552 * Special cases
553 */
554 case T_DeclareCursorStmt:
555 case T_ExplainStmt:
556 case T_CreateTableAsStmt:
557 case T_CallStmt:
558 result = true;
559 break;
560
561 default:
562 /* all other statements just get wrapped in a CMD_UTILITY Query */
563 result = false;
564 break;
565 }
566
567 return result;
568}
References nodeTag, and RawStmt::stmt.
Referenced by analyze_requires_snapshot().
◆ transformCallStmt()
|
static |
Definition at line 3282 of file analyze.c.
3283{
3284 List *targs;
3285 ListCell *lc;
3286 Node *node;
3287 FuncExpr *fexpr;
3288 HeapTuple proctup;
3289 Datum proargmodes;
3290 bool isNull;
3292 Query *result;
3293
3294 /*
3295 * First, do standard parse analysis on the procedure call and its
3296 * arguments, allowing us to identify the called procedure.
3297 */
3298 targs = NIL;
3300 {
3303 EXPR_KIND_CALL_ARGUMENT));
3304 }
3305
3306 node = ParseFuncOrColumn(pstate,
3307 stmt->funccall->funcname,
3308 targs,
3309 pstate->p_last_srf,
3310 stmt->funccall,
3311 true,
3312 stmt->funccall->location);
3313
3314 assign_expr_collations(pstate, node);
3315
3317
3321
3322 /*
3323 * Expand the argument list to deal with named-argument notation and
3324 * default arguments. For ordinary FuncExprs this'd be done during
3325 * planning, but a CallStmt doesn't go through planning, and there seems
3326 * no good reason not to do it here.
3327 */
3329 true,
3330 fexpr->funcresulttype,
3331 proctup);
3332
3333 /* Fetch proargmodes; if it's null, there are no output args */
3334 proargmodes = SysCacheGetAttr(PROCOID, proctup,
3335 Anum_pg_proc_proargmodes,
3336 &isNull);
3337 if (!isNull)
3338 {
3339 /*
3340 * Split the list into input arguments in fexpr->args and output
3341 * arguments in stmt->outargs. INOUT arguments appear in both lists.
3342 */
3343 ArrayType *arr;
3344 int numargs;
3345 char *argmodes;
3346 List *inargs;
3348
3352 ARR_DIMS(arr)[0] != numargs ||
3353 ARR_HASNULL(arr) ||
3354 ARR_ELEMTYPE(arr) != CHAROID)
3356 numargs);
3358
3359 inargs = NIL;
3360 i = 0;
3362 {
3364
3366 {
3367 case PROARGMODE_IN:
3368 case PROARGMODE_VARIADIC:
3369 inargs = lappend(inargs, n);
3370 break;
3371 case PROARGMODE_OUT:
3372 outargs = lappend(outargs, n);
3373 break;
3374 case PROARGMODE_INOUT:
3375 inargs = lappend(inargs, n);
3377 break;
3378 default:
3379 /* note we don't support PROARGMODE_TABLE */
3381 argmodes[i]);
3382 break;
3383 }
3384 i++;
3385 }
3386 fexpr->args = inargs;
3387 }
3388
3389 stmt->funcexpr = fexpr;
3390 stmt->outargs = outargs;
3391
3392 ReleaseSysCache(proctup);
3393
3394 /* represent the command as a utility Query */
3398
3399 return result;
3400}
List * expand_function_arguments(List *args, bool include_out_arguments, Oid result_type, HeapTuple func_tuple)
Definition: clauses.c:4177
void assign_expr_collations(ParseState *pstate, Node *expr)
Definition: parse_collate.c:177
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:118
Node * ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs, Node *last_srf, FuncCall *fn, bool proc_call, int location)
Definition: parse_func.c:90
Definition: array.h:93
Definition: primnodes.h:763
Definition: htup.h:63
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:600
References FuncExpr::args, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, assign_expr_collations(), castNode, CMD_UTILITY, Query::commandType, copyObject, DatumGetArrayTypeP, elog, ERROR, expand_function_arguments(), EXPR_KIND_CALL_ARGUMENT, FuncExpr::funcid, HeapTupleIsValid, i, lappend(), lfirst, list_length(), makeNode, NIL, ObjectIdGetDatum(), ParseState::p_last_srf, ParseFuncOrColumn(), ReleaseSysCache(), SearchSysCache1(), stmt, SysCacheGetAttr(), transformExpr(), and Query::utilityStmt.
Referenced by transformStmt().
◆ transformCreateTableAsStmt()
|
static |
Definition at line 3207 of file analyze.c.
3208{
3209 Query *result;
3210 Query *query;
3211
3212 /* transform contained query, not allowing SELECT INTO */
3215
3216 /* additional work needed for CREATE MATERIALIZED VIEW */
3218 {
3219 /*
3220 * Prohibit a data-modifying CTE in the query used to create a
3221 * materialized view. It's not sufficiently clear what the user would
3222 * want to happen if the MV is refreshed or incrementally maintained.
3223 */
3224 if (query->hasModifyingCTE)
3226 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3228
3229 /*
3230 * Check whether any temporary database objects are used in the
3231 * creation query. It would be hard to refresh data or incrementally
3232 * maintain it if a source disappeared.
3233 */
3236 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3238
3239 /*
3240 * A materialized view would either need to save parameters for use in
3241 * maintaining/loading the data or prohibit them entirely. The latter
3242 * seems safer and more sane.
3243 */
3246 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3248
3249 /*
3250 * For now, we disallow unlogged materialized views, because it seems
3251 * like a bad idea for them to just go to empty after a crash. (If we
3252 * could mark them as unpopulated, that would be better, but that
3253 * requires catalog changes which crash recovery can't presently
3254 * handle.)
3255 */
3258 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3260
3261 /*
3262 * At runtime, we'll need a copy of the parsed-but-not-rewritten Query
3263 * for purposes of creating the view's ON SELECT rule. We stash that
3264 * in the IntoClause because that's where intorel_startup() can
3265 * conveniently get it from.
3266 */
3268 }
3269
3270 /* represent the command as a utility Query */
3274
3275 return result;
3276}
bool query_contains_extern_params(Query *query)
Definition: parse_param.c:331
bool isQueryUsingTempRelation(Query *query)
Definition: parse_relation.c:3926
References CMD_UTILITY, Query::commandType, copyObject, ereport, errcode(), errmsg(), ERROR, isQueryUsingTempRelation(), makeNode, OBJECT_MATVIEW, query_contains_extern_params(), stmt, transformStmt(), and Query::utilityStmt.
Referenced by transformStmt().
◆ transformDeclareCursorStmt()
|
static |
Definition at line 3062 of file analyze.c.
3063{
3064 Query *result;
3065 Query *query;
3066
3070 (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3071 /* translator: %s is a SQL keyword */
3073 "SCROLL", "NO SCROLL")));
3074
3078 (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3079 /* translator: %s is a SQL keyword */
3081 "ASENSITIVE", "INSENSITIVE")));
3082
3083 /* Transform contained query, not allowing SELECT INTO */
3086
3087 /* Grammar should not have allowed anything but SELECT */
3091
3092 /*
3093 * We also disallow data-modifying WITH in a cursor. (This could be
3094 * allowed, but the semantics of when the updates occur might be
3095 * surprising.)
3096 */
3097 if (query->hasModifyingCTE)
3099 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3101
3102 /* FOR UPDATE and WITH HOLD are not compatible */
3105 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3106 /*------
3107 translator: %s is a SQL row locking clause such as FOR UPDATE */
3112
3113 /* FOR UPDATE and SCROLL are not compatible */
3116 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3117 /*------
3118 translator: %s is a SQL row locking clause such as FOR UPDATE */
3123
3124 /* FOR UPDATE and INSENSITIVE are not compatible */
3127 (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3128 /*------
3129 translator: %s is a SQL row locking clause such as FOR UPDATE */
3134
3135 /* represent the command as a utility Query */
3139
3140 return result;
3141}
References CMD_SELECT, CMD_UTILITY, Query::commandType, CURSOR_OPT_ASENSITIVE, CURSOR_OPT_HOLD, CURSOR_OPT_INSENSITIVE, CURSOR_OPT_NO_SCROLL, CURSOR_OPT_SCROLL, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, IsA, LCS_asString(), linitial, makeNode, NIL, Query::rowMarks, stmt, transformStmt(), and Query::utilityStmt.
Referenced by transformStmt().
◆ transformDeleteStmt()
|
static |
Definition at line 599 of file analyze.c.
600{
602 ParseNamespaceItem *nsitem;
603 Node *qual;
604
606
607 /* process the WITH clause independently of all else */
609 {
610 qry->hasRecursive = stmt->withClause->recursive;
612 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
613 }
614
615 /* set up range table with just the result rel */
617 stmt->relation->inh,
618 true,
619 ACL_DELETE);
620 nsitem = pstate->p_target_nsitem;
621
622 /* there's no DISTINCT in DELETE */
624
625 /* subqueries in USING cannot access the result relation */
628
629 /*
630 * The USING clause is non-standard SQL syntax, and is equivalent in
631 * functionality to the FROM list that can be specified for UPDATE. The
632 * USING keyword is used rather than FROM because FROM is already a
633 * keyword in the DELETE syntax.
634 */
636
637 /* remaining clauses can reference the result relation normally */
640
643
645 EXPR_KIND_RETURNING);
646
647 /* done building the range table and jointree */
649 qry->rteperminfos = pstate->p_rteperminfos;
651
652 qry->hasSubLinks = pstate->p_hasSubLinks;
653 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
654 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
655 qry->hasAggs = pstate->p_hasAggs;
656
657 assign_query_collations(pstate, qry);
658
659 /* this must be done after collations, for reliable comparison of exprs */
661 parseCheckAggregates(pstate, qry);
662
663 return qry;
664}
void parseCheckAggregates(ParseState *pstate, Query *qry)
Definition: parse_agg.c:1085
Node * transformWhereClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName)
Definition: parse_clause.c:1854
void transformFromClause(ParseState *pstate, List *frmList)
Definition: parse_clause.c:112
int setTargetTable(ParseState *pstate, RangeVar *relation, bool inh, bool alsoSource, AclMode requiredPerms)
Definition: parse_clause.c:178
void assign_query_collations(ParseState *pstate, Query *query)
Definition: parse_collate.c:101
List * transformWithClause(ParseState *pstate, WithClause *withClause)
Definition: parse_cte.c:109
void transformReturningClause(ParseState *pstate, Query *qry, ReturningClause *returningClause, ParseExprKind exprKind)
Definition: analyze.c:2691
References ACL_DELETE, assign_query_collations(), CMD_DELETE, Query::commandType, Query::cteList, Query::distinctClause, EXPR_KIND_RETURNING, EXPR_KIND_WHERE, Query::jointree, makeFromExpr(), makeNode, NIL, ParseState::p_hasAggs, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseNamespaceItem::p_lateral_ok, ParseNamespaceItem::p_lateral_only, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_target_nsitem, parseCheckAggregates(), Query::rtable, setTargetTable(), stmt, transformFromClause(), transformReturningClause(), transformWhereClause(), and transformWithClause().
Referenced by transformStmt().
◆ transformExplainStmt()
|
static |
Definition at line 3155 of file analyze.c.
3156{
3157 Query *result;
3158 bool generic_plan = false;
3159 Oid *paramTypes = NULL;
3160 int numParams = 0;
3161
3162 /*
3163 * If we have no external source of parameter definitions, and the
3164 * GENERIC_PLAN option is specified, then accept variable parameter
3165 * definitions (similarly to PREPARE, for example).
3166 */
3168 {
3169 ListCell *lc;
3170
3172 {
3174
3176 generic_plan = defGetBoolean(opt);
3177 /* don't "break", as we want the last value */
3178 }
3179 if (generic_plan)
3180 setup_parse_variable_parameters(pstate, ¶mTypes, &numParams);
3181 }
3182
3183 /* transform contained query, allowing SELECT INTO */
3185
3186 /* make sure all is well with parameter types */
3187 if (generic_plan)
3189
3190 /* represent the command as a utility Query */
3194
3195 return result;
3196}
static Query * transformOptionalSelectInto(ParseState *pstate, Node *parseTree)
Definition: analyze.c:357
Definition: parsenodes.h:823
References check_variable_parameters(), CMD_UTILITY, Query::commandType, defGetBoolean(), DefElem::defname, lfirst, makeNode, ParseState::p_paramref_hook, setup_parse_variable_parameters(), stmt, transformOptionalSelectInto(), and Query::utilityStmt.
Referenced by transformStmt().
◆ transformInsertRow()
| List * transformInsertRow | ( | ParseState * | pstate, |
| List * | exprlist, | ||
| List * | stmtcols, | ||
| List * | icolumns, | ||
| List * | attrnos, | ||
| bool | strip_indirection | ||
| ) |
Definition at line 1098 of file analyze.c.
1101{
1102 List *result;
1103 ListCell *lc;
1104 ListCell *icols;
1105 ListCell *attnos;
1106
1107 /*
1108 * Check length of expr list. It must not have more expressions than
1109 * there are target columns. We allow fewer, but only if no explicit
1110 * columns list was given (the remaining columns are implicitly
1111 * defaulted). Note we must check this *after* transformation because
1112 * that could expand '*' into multiple items.
1113 */
1116 (errcode(ERRCODE_SYNTAX_ERROR),
1118 parser_errposition(pstate,
1120 list_length(icolumns))))));
1123 {
1124 /*
1125 * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
1126 * where the user accidentally created a RowExpr instead of separate
1127 * columns. Add a suitable hint if that seems to be the problem,
1128 * because the main error message is quite misleading for this case.
1129 * (If there's no stmtcols, you'll get something about data type
1130 * mismatch, which is less misleading so we don't worry about giving a
1131 * hint in that case.)
1132 */
1134 (errcode(ERRCODE_SYNTAX_ERROR),
1136 ((list_length(exprlist) == 1 &&
1138 list_length(icolumns)) ?
1139 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),
1140 parser_errposition(pstate,
1142 list_length(exprlist))))));
1143 }
1144
1145 /*
1146 * Prepare columns for assignment to target table.
1147 */
1148 result = NIL;
1149 forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
1150 {
1154
1155 expr = transformAssignedExpr(pstate, expr,
1156 EXPR_KIND_INSERT_TARGET,
1157 col->name,
1158 attno,
1159 col->indirection,
1160 col->location);
1161
1162 if (strip_indirection)
1163 {
1164 /*
1165 * We need to remove top-level FieldStores and SubscriptingRefs,
1166 * as well as any CoerceToDomain appearing above one of those ---
1167 * but not a CoerceToDomain that isn't above one of those.
1168 */
1169 while (expr)
1170 {
1171 Expr *subexpr = expr;
1172
1174 {
1175 subexpr = ((CoerceToDomain *) subexpr)->arg;
1176 }
1178 {
1180
1182 }
1184 {
1186
1188 break;
1189
1190 expr = sbsref->refassgnexpr;
1191 }
1192 else
1193 break;
1194 }
1195 }
1196
1197 result = lappend(result, expr);
1198 }
1199
1200 return result;
1201}
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
Expr * transformAssignedExpr(ParseState *pstate, Expr *expr, ParseExprKind exprKind, const char *colname, int attrno, List *indirection, int location)
Definition: parse_target.c:455
static int count_rowexpr_columns(ParseState *pstate, Node *expr)
Definition: analyze.c:1385
Definition: primnodes.h:2057
Definition: primnodes.h:1173
Definition: parsenodes.h:526
Definition: primnodes.h:696
References count_rowexpr_columns(), ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_INSERT_TARGET, exprLocation(), forthree, ResTarget::indirection, IsA, lappend(), lfirst, lfirst_int, lfirst_node, linitial, list_length(), list_nth(), ResTarget::location, ResTarget::name, FieldStore::newvals, NIL, parser_errposition(), SubscriptingRef::refassgnexpr, and transformAssignedExpr().
Referenced by transformInsertStmt(), and transformMergeStmt().
◆ transformInsertStmt()
|
static |
Definition at line 671 of file analyze.c.
672{
676 bool isGeneralSelect;
677 List *sub_rtable;
678 List *sub_rteperminfos;
679 List *sub_namespace;
680 List *icolumns;
681 List *attrnos;
682 ParseNamespaceItem *nsitem;
683 RTEPermissionInfo *perminfo;
684 ListCell *icols;
685 ListCell *attnos;
686 ListCell *lc;
687 bool isOnConflictUpdate;
688 AclMode targetPerms;
689
690 /* There can't be any outer WITH to worry about */
692
695
696 /* process the WITH clause independently of all else */
698 {
699 qry->hasRecursive = stmt->withClause->recursive;
701 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
702 }
703
704 qry->override = stmt->override;
705
706 isOnConflictUpdate = (stmt->onConflictClause &&
708
709 /*
710 * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL),
711 * VALUES list, or general SELECT input. We special-case VALUES, both for
712 * efficiency and so we can handle DEFAULT specifications.
713 *
714 * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a
715 * VALUES clause. If we have any of those, treat it as a general SELECT;
716 * so it will work, but you can't use DEFAULT items together with those.
717 */
720 selectStmt->limitOffset != NULL ||
721 selectStmt->limitCount != NULL ||
723 selectStmt->withClause != NULL));
724
725 /*
726 * If a non-nil rangetable/namespace was passed in, and we are doing
727 * INSERT/SELECT, arrange to pass the rangetable/rteperminfos/namespace
728 * down to the SELECT. This can only happen if we are inside a CREATE
729 * RULE, and in that case we want the rule's OLD and NEW rtable entries to
730 * appear as part of the SELECT's rtable, not as outer references for it.
731 * (Kluge!) The SELECT's joinlist is not affected however. We must do
732 * this before adding the target table to the INSERT's rtable.
733 */
734 if (isGeneralSelect)
735 {
736 sub_rtable = pstate->p_rtable;
738 sub_rteperminfos = pstate->p_rteperminfos;
740 sub_namespace = pstate->p_namespace;
742 }
743 else
744 {
746 sub_rteperminfos = NIL;
747 sub_namespace = NIL;
748 }
749
750 /*
751 * Must get write lock on INSERT target table before scanning SELECT, else
752 * we will grab the wrong kind of initial lock if the target table is also
753 * mentioned in the SELECT part. Note that the target table is not added
754 * to the joinlist or namespace.
755 */
756 targetPerms = ACL_INSERT;
757 if (isOnConflictUpdate)
758 targetPerms |= ACL_UPDATE;
760 false, false, targetPerms);
761
762 /* Validate stmt->cols list, or build default list if no list given */
765
766 /*
767 * Determine which variant of INSERT we have.
768 */
769 if (selectStmt == NULL)
770 {
771 /*
772 * We have INSERT ... DEFAULT VALUES. We can handle this case by
773 * emitting an empty targetlist --- all columns will be defaulted when
774 * the planner expands the targetlist.
775 */
776 exprList = NIL;
777 }
778 else if (isGeneralSelect)
779 {
780 /*
781 * We make the sub-pstate a child of the outer pstate so that it can
782 * see any Param definitions supplied from above. Since the outer
783 * pstate's rtable and namespace are presently empty, there are no
784 * side-effects of exposing names the sub-SELECT shouldn't be able to
785 * see.
786 */
788 Query *selectQuery;
789
790 /*
791 * Process the source SELECT.
792 *
793 * It is important that this be handled just like a standalone SELECT;
794 * otherwise the behavior of SELECT within INSERT might be different
795 * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had
796 * bugs of just that nature...)
797 *
798 * The sole exception is that we prevent resolving unknown-type
799 * outputs as TEXT. This does not change the semantics since if the
800 * column type matters semantically, it would have been resolved to
801 * something else anyway. Doing this lets us resolve such outputs as
802 * the target column's type, which we handle below.
803 */
804 sub_pstate->p_rtable = sub_rtable;
805 sub_pstate->p_rteperminfos = sub_rteperminfos;
808 sub_pstate->p_namespace = sub_namespace;
810
812
813 free_parsestate(sub_pstate);
814
815 /* The grammar should have produced a SELECT */
819
820 /*
821 * Make the source be a subquery in the INSERT's rangetable, and add
822 * it to the INSERT's joinlist (but not the namespace).
823 */
824 nsitem = addRangeTableEntryForSubquery(pstate,
825 selectQuery,
827 false,
828 false);
830
831 /*----------
832 * Generate an expression list for the INSERT that selects all the
833 * non-resjunk columns from the subquery. (INSERT's tlist must be
834 * separate from the subquery's tlist because we may add columns,
835 * insert datatype coercions, etc.)
836 *
837 * HACK: unknown-type constants and params in the SELECT's targetlist
838 * are copied up as-is rather than being referenced as subquery
839 * outputs. This is to ensure that when we try to coerce them to
840 * the target column's datatype, the right things happen (see
841 * special cases in coerce_type). Otherwise, this fails:
842 * INSERT INTO foo SELECT 'bar', ... FROM baz
843 *----------
844 */
845 exprList = NIL;
847 {
849 Expr *expr;
850
851 if (tle->resjunk)
852 continue;
856 expr = tle->expr;
857 else
858 {
860
862 expr = (Expr *) var;
863 }
864 exprList = lappend(exprList, expr);
865 }
866
867 /* Prepare row for assignment to target table */
868 exprList = transformInsertRow(pstate, exprList,
869 stmt->cols,
870 icolumns, attrnos,
871 false);
872 }
874 {
875 /*
876 * Process INSERT ... VALUES with multiple VALUES sublists. We
877 * generate a VALUES RTE holding the transformed expression lists, and
878 * build up a targetlist containing Vars that reference the VALUES
879 * RTE.
880 */
885 int sublist_length = -1;
886 bool lateral = false;
887
889
891 {
893
894 /*
895 * Do basic expression transformation (same as a ROW() expr, but
896 * allow SetToDefault at top level)
897 */
898 sublist = transformExpressionList(pstate, sublist,
900
901 /*
902 * All the sublists must be the same length, *after*
903 * transformation (which might expand '*' into multiple items).
904 * The VALUES RTE can't handle anything different.
905 */
906 if (sublist_length < 0)
907 {
908 /* Remember post-transformation length of first sublist */
909 sublist_length = list_length(sublist);
910 }
912 {
914 (errcode(ERRCODE_SYNTAX_ERROR),
916 parser_errposition(pstate,
918 }
919
920 /*
921 * Prepare row for assignment to target table. We process any
922 * indirection on the target column specs normally but then strip
923 * off the resulting field/array assignment nodes, since we don't
924 * want the parsed statement to contain copies of those in each
925 * VALUES row. (It's annoying to have to transform the
926 * indirection specs over and over like this, but avoiding it
927 * would take some really messy refactoring of
928 * transformAssignmentIndirection.)
929 */
930 sublist = transformInsertRow(pstate, sublist,
931 stmt->cols,
932 icolumns, attrnos,
933 true);
934
935 /*
936 * We must assign collations now because assign_query_collations
937 * doesn't process rangetable entries. We just assign all the
938 * collations independently in each row, and don't worry about
939 * whether they are consistent vertically. The outer INSERT query
940 * isn't going to care about the collations of the VALUES columns,
941 * so it's not worth the effort to identify a common collation for
942 * each one here. (But note this does have one user-visible
943 * consequence: INSERT ... VALUES won't complain about conflicting
944 * explicit COLLATEs in a column, whereas the same VALUES
945 * construct in another context would complain.)
946 */
947 assign_list_collations(pstate, sublist);
948
949 exprsLists = lappend(exprsLists, sublist);
950 }
951
952 /*
953 * Construct column type/typmod/collation lists for the VALUES RTE.
954 * Every expression in each column has been coerced to the type/typmod
955 * of the corresponding target column or subfield, so it's sufficient
956 * to look at the exprType/exprTypmod of the first row. We don't care
957 * about the collation labeling, so just fill in InvalidOid for that.
958 */
960 {
962
966 }
967
968 /*
969 * Ordinarily there can't be any current-level Vars in the expression
970 * lists, because the namespace was empty ... but if we're inside
971 * CREATE RULE, then NEW/OLD references might appear. In that case we
972 * have to mark the VALUES RTE as LATERAL.
973 */
976 lateral = true;
977
978 /*
979 * Generate the VALUES RTE
980 */
981 nsitem = addRangeTableEntryForValues(pstate, exprsLists,
982 coltypes, coltypmods, colcollations,
983 NULL, lateral, true);
985
986 /*
987 * Generate list of Vars referencing the RTE
988 */
989 exprList = expandNSItemVars(pstate, nsitem, 0, -1, NULL);
990
991 /*
992 * Re-apply any indirection on the target column specs to the Vars
993 */
994 exprList = transformInsertRow(pstate, exprList,
995 stmt->cols,
996 icolumns, attrnos,
997 false);
998 }
999 else
1000 {
1001 /*
1002 * Process INSERT ... VALUES with a single VALUES sublist. We treat
1003 * this case separately for efficiency. The sublist is just computed
1004 * directly as the Query's targetlist, with no VALUES RTE. So it
1005 * works just like a SELECT without any FROM.
1006 */
1008
1011
1012 /*
1013 * Do basic expression transformation (same as a ROW() expr, but allow
1014 * SetToDefault at top level)
1015 */
1016 exprList = transformExpressionList(pstate,
1018 EXPR_KIND_VALUES_SINGLE,
1019 true);
1020
1021 /* Prepare row for assignment to target table */
1022 exprList = transformInsertRow(pstate, exprList,
1023 stmt->cols,
1024 icolumns, attrnos,
1025 false);
1026 }
1027
1028 /*
1029 * Generate query's target list using the computed list of expressions.
1030 * Also, mark all the target columns as needing insert permissions.
1031 */
1035 forthree(lc, exprList, icols, icolumns, attnos, attrnos)
1036 {
1040 TargetEntry *tle;
1041
1042 tle = makeTargetEntry(expr,
1043 attr_num,
1044 col->name,
1045 false);
1047
1048 perminfo->insertedCols = bms_add_member(perminfo->insertedCols,
1049 attr_num - FirstLowInvalidHeapAttributeNumber);
1050 }
1051
1052 /*
1053 * If we have any clauses yet to process, set the query namespace to
1054 * contain only the target relation, removing any entries added in a
1055 * sub-SELECT or VALUES list.
1056 */
1058 {
1061 false, true, true);
1062 }
1063
1064 /* Process ON CONFLICT, if any. */
1067 stmt->onConflictClause);
1068
1069 /* Process RETURNING, if any. */
1072 EXPR_KIND_RETURNING);
1073
1074 /* done building the range table and jointree */
1076 qry->rteperminfos = pstate->p_rteperminfos;
1078
1079 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
1080 qry->hasSubLinks = pstate->p_hasSubLinks;
1081
1082 assign_query_collations(pstate, qry);
1083
1084 return qry;
1085}
Var * makeVarFromTargetEntry(int varno, TargetEntry *tle)
Definition: makefuncs.c:107
void assign_list_collations(ParseState *pstate, List *exprs)
Definition: parse_collate.c:155
List * expandNSItemVars(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, int location, List **colnames)
Definition: parse_relation.c:3223
ParseNamespaceItem * addRangeTableEntryForSubquery(ParseState *pstate, Query *subquery, Alias *alias, bool lateral, bool inFromCl)
Definition: parse_relation.c:1651
ParseNamespaceItem * addRangeTableEntryForValues(ParseState *pstate, List *exprs, List *coltypes, List *coltypmods, List *colcollations, Alias *alias, bool lateral, bool inFromCl)
Definition: parse_relation.c:2147
List * transformExpressionList(ParseState *pstate, List *exprlist, ParseExprKind exprKind, bool allowDefault)
Definition: parse_target.c:220
List * checkInsertTargets(ParseState *pstate, List *cols, List **attrnos)
Definition: parse_target.c:1018
static OnConflictExpr * transformOnConflictClause(ParseState *pstate, OnConflictClause *onConflictClause)
Definition: analyze.c:1208
List * transformInsertRow(ParseState *pstate, List *exprlist, List *stmtcols, List *icolumns, List *attrnos, bool strip_indirection)
Definition: analyze.c:1098
Definition: primnodes.h:323
Definition: primnodes.h:390
Definition: parsenodes.h:1295
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
References ACL_INSERT, ACL_UPDATE, addNSItemToQuery(), addRangeTableEntryForSubquery(), Assert, checkInsertTargets(), CMD_INSERT, CMD_SELECT, Query::commandType, Query::cteList, elog, ERROR, TargetEntry::expr, exprLocation(), exprType(), free_parsestate(), IsA, lappend(), lfirst, SelectStmt::limitCount, SelectStmt::limitOffset, list_length(), Var::location, SelectStmt::lockingClause, make_parsestate(), makeAlias(), makeNode, makeVarFromTargetEntry(), NIL, ONCONFLICT_UPDATE, ParseState::p_ctenamespace, ParseState::p_hasModifyingCTE, ParseState::p_is_insert, ParseState::p_joinexprs, ParseState::p_namespace, ParseState::p_nullingrels, ParseState::p_resolve_unknowns, ParseState::p_rtable, ParseState::p_rteperminfos, setTargetTable(), SelectStmt::sortClause, stmt, Query::targetList, transformInsertRow(), transformStmt(), transformWithClause(), SelectStmt::valuesLists, and SelectStmt::withClause.
Referenced by transformStmt().
◆ transformLockingClause()
|
static |
Definition at line 3496 of file analyze.c.
3498{
3500 ListCell *l;
3501 ListCell *rt;
3503 LockingClause *allrels;
3504
3506
3507 /* make a clause we can pass down to subqueries to select all rels */
3512
3514 {
3515 /*
3516 * Lock all regular tables used in query and its subqueries. We
3517 * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
3518 * in rules. This is a bit of an abuse of a mostly-obsolete flag, but
3519 * it's convenient. We can't rely on the namespace mechanism that has
3520 * largely replaced inFromCl, since for example we need to lock
3521 * base-relation RTEs even if they are masked by upper joins.
3522 */
3523 i = 0;
3525 {
3527
3528 ++i;
3529 if (!rte->inFromCl)
3530 continue;
3532 {
3534 {
3535 RTEPermissionInfo *perminfo;
3536
3538 lc->strength,
3539 lc->waitPolicy,
3540 pushedDown);
3541 perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
3543 }
3544 break;
3547 pushedDown);
3548
3549 /*
3550 * FOR UPDATE/SHARE of subquery is propagated to all of
3551 * subquery's rels, too. We could do this later (based on
3552 * the marking of the subquery RTE) but it is convenient
3553 * to have local knowledge in each query level about which
3554 * rels need to be opened with RowShareLock.
3555 */
3557 allrels, true);
3558 break;
3559 default:
3560 /* ignore JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */
3561 break;
3562 }
3563 }
3564 }
3565 else
3566 {
3567 /*
3568 * Lock just the named tables. As above, we allow locking any base
3569 * relation regardless of alias-visibility rules, so we need to
3570 * examine inFromCl to exclude OLD/NEW.
3571 */
3572 foreach(l, lockedRels)
3573 {
3575
3576 /* For simplicity we insist on unqualified alias names here */
3579 (errcode(ERRCODE_SYNTAX_ERROR),
3580 /*------
3581 translator: %s is a SQL row locking clause such as FOR UPDATE */
3585
3586 i = 0;
3588 {
3590 char *rtename = rte->eref->aliasname;
3591
3592 ++i;
3593 if (!rte->inFromCl)
3594 continue;
3595
3596 /*
3597 * A join RTE without an alias is not visible as a relation
3598 * name and needs to be skipped (otherwise it might hide a
3599 * base relation with the same name), except if it has a USING
3600 * alias, which *is* visible.
3601 *
3602 * Subquery and values RTEs without aliases are never visible
3603 * as relation names and must always be skipped.
3604 */
3605 if (rte->alias == NULL)
3606 {
3608 {
3609 if (rte->join_using_alias == NULL)
3610 continue;
3611 rtename = rte->join_using_alias->aliasname;
3612 }
3615 continue;
3616 }
3617
3619 {
3621 {
3623 {
3624 RTEPermissionInfo *perminfo;
3625
3627 lc->strength,
3628 lc->waitPolicy,
3629 pushedDown);
3630 perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
3632 }
3633 break;
3636 lc->waitPolicy, pushedDown);
3637 /* see comment above */
3639 allrels, true);
3640 break;
3643 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3644 /*------
3645 translator: %s is a SQL row locking clause such as FOR UPDATE */
3649 break;
3652 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3653 /*------
3654 translator: %s is a SQL row locking clause such as FOR UPDATE */
3658 break;
3661 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3662 /*------
3663 translator: %s is a SQL row locking clause such as FOR UPDATE */
3667 break;
3670 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3671 /*------
3672 translator: %s is a SQL row locking clause such as FOR UPDATE */
3676 break;
3679 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3680 /*------
3681 translator: %s is a SQL row locking clause such as FOR UPDATE */
3685 break;
3688 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3689 /*------
3690 translator: %s is a SQL row locking clause such as FOR UPDATE */
3694 break;
3695
3696 /* Shouldn't be possible to see RTE_RESULT here */
3697
3698 default:
3701 break;
3702 }
3703 break; /* out of foreach loop */
3704 }
3705 }
3706 if (rt == NULL)
3709 /*------
3710 translator: %s is a SQL row locking clause such as FOR UPDATE */
3712 thisrel->relname,
3715 }
3716 }
3717}
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
Definition: parse_relation.c:4005
static void transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc, bool pushedDown)
Definition: analyze.c:3496
void CheckSelectLocking(Query *qry, LockClauseStrength strength)
Definition: analyze.c:3432
void applyLockingClause(Query *qry, Index rtindex, LockClauseStrength strength, LockWaitPolicy waitPolicy, bool pushedDown)
Definition: analyze.c:3723
Definition: parsenodes.h:843
Definition: primnodes.h:72
References ACL_SELECT_FOR_UPDATE, applyLockingClause(), RangeVar::catalogname, CheckSelectLocking(), elog, ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, getRTEPermissionInfo(), i, LCS_asString(), lfirst, RangeVar::location, LockingClause::lockedRels, makeNode, NIL, parser_errposition(), RangeVar::relname, RTEPermissionInfo::requiredPerms, Query::rtable, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RangeVar::schemaname, LockingClause::strength, RangeTblEntry::subquery, transformLockingClause(), and LockingClause::waitPolicy.
Referenced by transformLockingClause(), transformPLAssignStmt(), transformSelectStmt(), and transformSetOperationStmt().
◆ transformOnConflictClause()
|
static |
Definition at line 1208 of file analyze.c.
1210{
1211 ParseNamespaceItem *exclNSItem = NULL;
1212 List *arbiterElems;
1213 Node *arbiterWhere;
1214 Oid arbiterConstraint;
1216 Node *onConflictWhere = NULL;
1217 int exclRelIndex = 0;
1219 OnConflictExpr *result;
1220
1221 /*
1222 * If this is ON CONFLICT ... UPDATE, first create the range table entry
1223 * for the EXCLUDED pseudo relation, so that that will be present while
1224 * processing arbiter expressions. (You can't actually reference it from
1225 * there, but this provides a useful error message if you try.)
1226 */
1228 {
1230 RangeTblEntry *exclRte;
1231
1232 exclNSItem = addRangeTableEntryForRelation(pstate,
1233 targetrel,
1234 RowExclusiveLock,
1236 false, false);
1237 exclRte = exclNSItem->p_rte;
1238 exclRelIndex = exclNSItem->p_rtindex;
1239
1240 /*
1241 * relkind is set to composite to signal that we're not dealing with
1242 * an actual relation, and no permission checks are required on it.
1243 * (We'll check the actual target relation, instead.)
1244 */
1245 exclRte->relkind = RELKIND_COMPOSITE_TYPE;
1246
1247 /* Create EXCLUDED rel's targetlist for use by EXPLAIN */
1248 exclRelTlist = BuildOnConflictExcludedTargetlist(targetrel,
1249 exclRelIndex);
1250 }
1251
1252 /* Process the arbiter clause, ON CONFLICT ON (...) */
1253 transformOnConflictArbiter(pstate, onConflictClause, &arbiterElems,
1254 &arbiterWhere, &arbiterConstraint);
1255
1256 /* Process DO UPDATE */
1258 {
1259 /*
1260 * Expressions in the UPDATE targetlist need to be handled like UPDATE
1261 * not INSERT. We don't need to save/restore this because all INSERT
1262 * expressions have been parsed already.
1263 */
1265
1266 /*
1267 * Add the EXCLUDED pseudo relation to the query namespace, making it
1268 * available in the UPDATE subexpressions.
1269 */
1271
1272 /*
1273 * Now transform the UPDATE subexpressions.
1274 */
1275 onConflictSet =
1277
1278 onConflictWhere = transformWhereClause(pstate,
1279 onConflictClause->whereClause,
1281
1282 /*
1283 * Remove the EXCLUDED pseudo relation from the query namespace, since
1284 * it's not supposed to be available in RETURNING. (Maybe someday we
1285 * could allow that, and drop this step.)
1286 */
1289 }
1290
1291 /* Finally, build ON CONFLICT DO [NOTHING | UPDATE] expression */
1293
1295 result->arbiterElems = arbiterElems;
1296 result->arbiterWhere = arbiterWhere;
1297 result->constraint = arbiterConstraint;
1298 result->onConflictSet = onConflictSet;
1299 result->onConflictWhere = onConflictWhere;
1300 result->exclRelIndex = exclRelIndex;
1301 result->exclRelTlist = exclRelTlist;
1302
1303 return result;
1304}
void transformOnConflictArbiter(ParseState *pstate, OnConflictClause *onConflictClause, List **arbiterExpr, Node **arbiterWhere, Oid *constraint)
Definition: parse_clause.c:3297
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
Definition: parse_relation.c:1580
List * transformUpdateTargetList(ParseState *pstate, List *origTlist)
Definition: analyze.c:2576
List * BuildOnConflictExcludedTargetlist(Relation targetrel, Index exclRelIndex)
Definition: analyze.c:1315
Definition: primnodes.h:2377
Definition: rel.h:56
References OnConflictClause::action, OnConflictExpr::action, addNSItemToQuery(), addRangeTableEntryForRelation(), OnConflictExpr::arbiterElems, OnConflictExpr::arbiterWhere, Assert, BuildOnConflictExcludedTargetlist(), OnConflictExpr::constraint, OnConflictExpr::exclRelIndex, OnConflictExpr::exclRelTlist, EXPR_KIND_WHERE, list_delete_last(), llast, makeAlias(), makeNode, NIL, ONCONFLICT_UPDATE, OnConflictExpr::onConflictSet, OnConflictExpr::onConflictWhere, ParseState::p_is_insert, ParseState::p_namespace, ParseNamespaceItem::p_rte, ParseNamespaceItem::p_rtindex, ParseState::p_target_relation, RowExclusiveLock, OnConflictClause::targetList, transformOnConflictArbiter(), transformUpdateTargetList(), transformWhereClause(), and OnConflictClause::whereClause.
◆ transformOptionalSelectInto()
|
static |
Definition at line 357 of file analyze.c.
358{
360 {
362
363 /* If it's a set-operation tree, drill down to leftmost SelectStmt */
367
369 {
371
372 ctas->query = parseTree;
376
377 /*
378 * Remove the intoClause from the SelectStmt. This makes it safe
379 * for transformSelectStmt to complain if it finds intoClause set
380 * (implying that the INTO appeared in a disallowed place).
381 */
382 stmt->intoClause = NULL;
383
384 parseTree = (Node *) ctas;
385 }
386 }
387
389}
Definition: parsenodes.h:3964
References Assert, CreateTableAsStmt::into, CreateTableAsStmt::is_select_into, IsA, makeNode, OBJECT_TABLE, CreateTableAsStmt::objtype, CreateTableAsStmt::query, SETOP_NONE, stmt, and transformStmt().
Referenced by transformExplainStmt(), and transformTopLevelStmt().
◆ transformPLAssignStmt()
|
static |
Definition at line 2813 of file analyze.c.
2814{
2820 Node *target;
2821 Oid targettype;
2822 int32 targettypmod;
2823 Oid targetcollation;
2824 List *tlist;
2825 TargetEntry *tle;
2826 Oid type_id;
2827 Node *qual;
2828 ListCell *l;
2829
2830 /*
2831 * First, construct a ColumnRef for the target variable. If the target
2832 * has more than one dotted name, we have to pull the extra names out of
2833 * the indirection list.
2834 */
2837 if (nnames > 1)
2838 {
2839 /* avoid munging the raw parsetree */
2840 indirection = list_copy(indirection);
2842 {
2844
2848 indirection = list_delete_first(indirection);
2849 }
2850 }
2851
2852 /*
2853 * Transform the target reference. Typically we will get back a Param
2854 * node, but there's no reason to be too picky about its type.
2855 */
2857 EXPR_KIND_UPDATE_TARGET);
2858 targettype = exprType(target);
2859 targettypmod = exprTypmod(target);
2860 targetcollation = exprCollation(target);
2861
2862 /*
2863 * The rest mostly matches transformSelectStmt, except that we needn't
2864 * consider WITH or INTO, and we build a targetlist our own way.
2865 */
2868
2869 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
2871
2872 /* make WINDOW info available for window functions, too */
2874
2875 /* process the FROM clause */
2877
2878 /* initially transform the targetlist as if in SELECT */
2880 EXPR_KIND_SELECT_TARGET);
2881
2882 /* we should have exactly one targetlist item */
2885 (errcode(ERRCODE_SYNTAX_ERROR),
2887 "assignment source returned %d columns",
2888 list_length(tlist),
2889 list_length(tlist))));
2890
2892
2893 /*
2894 * This next bit is similar to transformAssignedExpr; the key difference
2895 * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT.
2896 */
2898
2900
2901 if (indirection)
2902 {
2904 transformAssignmentIndirection(pstate,
2905 target,
2906 stmt->name,
2907 false,
2908 targettype,
2909 targettypmod,
2910 targetcollation,
2911 indirection,
2912 list_head(indirection),
2914 COERCION_PLPGSQL,
2915 exprLocation(target));
2916 }
2917 else if (targettype != type_id &&
2918 (targettype == RECORDOID || ISCOMPLEX(targettype)) &&
2919 (type_id == RECORDOID || ISCOMPLEX(type_id)))
2920 {
2921 /*
2922 * Hack: do not let coerce_to_target_type() deal with inconsistent
2923 * composite types. Just pass the expression result through as-is,
2924 * and let the PL/pgSQL executor do the conversion its way. This is
2925 * rather bogus, but it's needed for backwards compatibility.
2926 */
2927 }
2928 else
2929 {
2930 /*
2931 * For normal non-qualified target column, do type checking and
2932 * coercion.
2933 */
2935
2937 coerce_to_target_type(pstate,
2938 orig_expr, type_id,
2939 targettype, targettypmod,
2940 COERCION_PLPGSQL,
2941 COERCE_IMPLICIT_CAST,
2942 -1);
2943 /* With COERCION_PLPGSQL, this error is probably unreachable */
2946 (errcode(ERRCODE_DATATYPE_MISMATCH),
2948 " but expression is of type %s",
2949 stmt->name,
2950 format_type_be(targettype),
2951 format_type_be(type_id)),
2954 }
2955
2957
2959
2960 /* transform WHERE */
2963
2964 /* initial processing of HAVING clause is much like WHERE clause */
2967
2968 /*
2969 * Transform sorting/grouping stuff. Do ORDER BY first because both
2970 * transformGroupClause and transformDistinctClause need the results. Note
2971 * that these functions can also change the targetList, so it's passed to
2972 * them by reference.
2973 */
2975 sstmt->sortClause,
2976 &qry->targetList,
2977 EXPR_KIND_ORDER_BY,
2978 false /* allow SQL92 rules */ );
2979
2981 sstmt->groupClause,
2982 &qry->groupingSets,
2983 &qry->targetList,
2984 qry->sortClause,
2985 EXPR_KIND_GROUP_BY,
2986 false /* allow SQL92 rules */ );
2987
2989 {
2991 qry->hasDistinctOn = false;
2992 }
2994 {
2995 /* We had SELECT DISTINCT */
2997 &qry->targetList,
2998 qry->sortClause,
2999 false);
3000 qry->hasDistinctOn = false;
3001 }
3002 else
3003 {
3004 /* We had SELECT DISTINCT ON */
3006 sstmt->distinctClause,
3007 &qry->targetList,
3008 qry->sortClause);
3009 qry->hasDistinctOn = true;
3010 }
3011
3012 /* transform LIMIT */
3015 sstmt->limitOption);
3018 sstmt->limitOption);
3020
3021 /* transform window clauses after we have seen all window functions */
3023 pstate->p_windowdefs,
3024 &qry->targetList);
3025
3027 qry->rteperminfos = pstate->p_rteperminfos;
3029
3030 qry->hasSubLinks = pstate->p_hasSubLinks;
3031 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
3032 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
3033 qry->hasAggs = pstate->p_hasAggs;
3034
3036 {
3037 transformLockingClause(pstate, qry,
3039 }
3040
3041 assign_query_collations(pstate, qry);
3042
3043 /* this must be done after collations, for reliable comparison of exprs */
3045 parseCheckAggregates(pstate, qry);
3046
3047 return qry;
3048}
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1180
List * transformGroupClause(ParseState *pstate, List *grouplist, List **groupingSets, List **targetlist, List *sortClause, ParseExprKind exprKind, bool useSQL99)
Definition: parse_clause.c:2632
List * transformSortClause(ParseState *pstate, List *orderlist, List **targetlist, ParseExprKind exprKind, bool useSQL99)
Definition: parse_clause.c:2732
List * transformDistinctOnClause(ParseState *pstate, List *distinctlist, List **targetlist, List *sortClause)
Definition: parse_clause.c:3069
List * transformWindowDefinitions(ParseState *pstate, List *windowdefs, List **targetlist)
Definition: parse_clause.c:2765
List * transformDistinctClause(ParseState *pstate, List **targetlist, List *sortClause, bool is_agg)
Definition: parse_clause.c:2985
Node * transformLimitClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName, LimitOption limitOption)
Definition: parse_clause.c:1881
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition: parse_coerce.c:78
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)
Definition: parse_target.c:686
List * transformTargetList(ParseState *pstate, List *targetlist, ParseExprKind exprKind)
Definition: parse_target.c:121
Definition: parsenodes.h:303
Definition: value.h:64
Definition: preproc-array_of_struct.c:43
References assign_query_collations(), CMD_SELECT, COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_PLPGSQL, Query::commandType, Query::distinctClause, SelectStmt::distinctClause, elog, ereport, errcode(), errhint(), errmsg(), errmsg_plural(), ERROR, TargetEntry::expr, EXPR_KIND_GROUP_BY, EXPR_KIND_HAVING, EXPR_KIND_LIMIT, EXPR_KIND_NONE, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_SELECT_TARGET, EXPR_KIND_UPDATE_TARGET, EXPR_KIND_WHERE, exprCollation(), exprLocation(), exprType(), exprTypmod(), ColumnRef::fields, format_type_be(), SelectStmt::fromClause, Query::groupClause, SelectStmt::groupClause, Query::groupingSets, SelectStmt::havingClause, Query::havingQual, IsA, ISCOMPLEX, Query::jointree, lappend(), lfirst, Query::limitCount, SelectStmt::limitCount, Query::limitOffset, SelectStmt::limitOffset, Query::limitOption, SelectStmt::limitOption, linitial, linitial_node, list_copy(), list_delete_first(), list_head(), list_length(), list_make1, ColumnRef::location, SelectStmt::lockingClause, makeFromExpr(), makeNode, makeString(), NIL, ParseState::p_expr_kind, ParseState::p_hasAggs, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_is_insert, ParseState::p_joinlist, ParseState::p_locking_clause, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_windowdefs, parseCheckAggregates(), parser_errposition(), Query::rtable, Query::sortClause, SelectStmt::sortClause, stmt, Query::targetList, SelectStmt::targetList, transformAssignmentIndirection(), transformDistinctClause(), transformDistinctOnClause(), transformExpr(), transformFromClause(), transformGroupClause(), transformLimitClause(), transformLockingClause(), transformSortClause(), transformTargetList(), transformWhereClause(), transformWindowDefinitions(), SelectStmt::whereClause, Query::windowClause, and SelectStmt::windowClause.
Referenced by transformStmt().
◆ transformReturningClause()
| void transformReturningClause | ( | ParseState * | pstate, |
| Query * | qry, | ||
| ReturningClause * | returningClause, | ||
| ParseExprKind | exprKind | ||
| ) |
Definition at line 2691 of file analyze.c.
2694{
2696 int save_next_resno;
2697
2698 if (returningClause == NULL)
2699 return; /* nothing to do */
2700
2701 /*
2702 * Scan RETURNING WITH(...) options for OLD/NEW alias names. Complain if
2703 * there is any conflict with existing relations.
2704 */
2706 {
2708 {
2710 if (qry->returningOldAlias != NULL)
2712 errcode(ERRCODE_SYNTAX_ERROR),
2713 /* translator: %s is OLD or NEW */
2716 qry->returningOldAlias = option->value;
2717 break;
2718
2720 if (qry->returningNewAlias != NULL)
2722 errcode(ERRCODE_SYNTAX_ERROR),
2723 /* translator: %s is OLD or NEW */
2726 qry->returningNewAlias = option->value;
2727 break;
2728
2729 default:
2731 }
2732
2735 errcode(ERRCODE_DUPLICATE_ALIAS),
2737 option->value),
2739
2743 }
2744
2745 /*
2746 * If OLD/NEW alias names weren't explicitly specified, use "old"/"new"
2747 * unless masked by existing relations.
2748 */
2749 if (qry->returningOldAlias == NULL &&
2751 {
2752 qry->returningOldAlias = "old";
2754 }
2755 if (qry->returningNewAlias == NULL &&
2757 {
2758 qry->returningNewAlias = "new";
2760 }
2761
2762 /*
2763 * We need to assign resnos starting at one in the RETURNING list. Save
2764 * and restore the main tlist's value of p_next_resno, just in case
2765 * someone looks at it later (probably won't happen).
2766 */
2767 save_next_resno = pstate->p_next_resno;
2768 pstate->p_next_resno = 1;
2769
2770 /* transform RETURNING expressions identically to a SELECT targetlist */
2772 returningClause->exprs,
2773 exprKind);
2774
2775 /*
2776 * Complain if the nonempty tlist expanded to nothing (which is possible
2777 * if it contains only a star-expansion of a zero-column table). If we
2778 * allow this, the parsed Query will look like it didn't have RETURNING,
2779 * with results that would probably surprise the user.
2780 */
2783 (errcode(ERRCODE_SYNTAX_ERROR),
2785 parser_errposition(pstate,
2787
2788 /* mark column origins */
2790
2791 /* resolve any still-unresolved output columns as being type text */
2794
2795 /* restore state */
2797 pstate->p_next_resno = save_next_resno;
2798}
ParseNamespaceItem * refnameNamespaceItem(ParseState *pstate, const char *schemaname, const char *refname, int location, int *sublevels_up)
Definition: parse_relation.c:134
void resolveTargetListUnknowns(ParseState *pstate, List *targetlist)
Definition: parse_target.c:288
void markTargetListOrigins(ParseState *pstate, List *targetlist)
Definition: parse_target.c:318
static void addNSItemForReturning(ParseState *pstate, const char *aliasname, VarReturningType returning_type)
Definition: analyze.c:2651
Definition: parsenodes.h:1755
Definition: getopt_long.h:18
References addNSItemForReturning(), elog, ereport, errcode(), errmsg(), ERROR, exprLocation(), ReturningClause::exprs, foreach_node, linitial, list_length(), list_truncate(), markTargetListOrigins(), NIL, ReturningClause::options, ParseState::p_namespace, ParseState::p_next_resno, ParseState::p_resolve_unknowns, parser_errposition(), refnameNamespaceItem(), resolveTargetListUnknowns(), RETURNING_OPTION_NEW, RETURNING_OPTION_OLD, Query::returningList, transformTargetList(), VAR_RETURNING_NEW, and VAR_RETURNING_OLD.
Referenced by transformDeleteStmt(), transformMergeStmt(), and transformUpdateStmt().
◆ transformReturnStmt()
|
static |
Definition at line 2479 of file analyze.c.
2480{
2482
2484 qry->isReturn = true;
2485
2486 qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET),
2487 1, NULL, false));
2488
2492 qry->rteperminfos = pstate->p_rteperminfos;
2494 qry->hasSubLinks = pstate->p_hasSubLinks;
2495 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
2496 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2497 qry->hasAggs = pstate->p_hasAggs;
2498
2499 assign_query_collations(pstate, qry);
2500
2501 return qry;
2502}
References assign_query_collations(), CMD_SELECT, Query::commandType, EXPR_KIND_SELECT_TARGET, Query::jointree, list_make1, makeFromExpr(), makeNode, makeTargetEntry(), ParseState::p_hasAggs, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseState::p_resolve_unknowns, ParseState::p_rtable, ParseState::p_rteperminfos, resolveTargetListUnknowns(), Query::rtable, stmt, Query::targetList, and transformExpr().
Referenced by transformStmt().
◆ transformSelectStmt()
|
static |
Definition at line 1427 of file analyze.c.
1428{
1430 Node *qual;
1431 ListCell *l;
1432
1434
1435 /* process the WITH clause independently of all else */
1437 {
1438 qry->hasRecursive = stmt->withClause->recursive;
1440 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1441 }
1442
1443 /* Complain if we get called from someplace where INTO is not allowed */
1446 (errcode(ERRCODE_SYNTAX_ERROR),
1448 parser_errposition(pstate,
1450
1451 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
1453
1454 /* make WINDOW info available for window functions, too */
1456
1457 /* process the FROM clause */
1459
1460 /* transform targetlist */
1462 EXPR_KIND_SELECT_TARGET);
1463
1464 /* mark column origins */
1466
1467 /* transform WHERE */
1470
1471 /* initial processing of HAVING clause is much like WHERE clause */
1474
1475 /*
1476 * Transform sorting/grouping stuff. Do ORDER BY first because both
1477 * transformGroupClause and transformDistinctClause need the results. Note
1478 * that these functions can also change the targetList, so it's passed to
1479 * them by reference.
1480 */
1482 stmt->sortClause,
1483 &qry->targetList,
1484 EXPR_KIND_ORDER_BY,
1485 false /* allow SQL92 rules */ );
1486
1488 stmt->groupClause,
1489 &qry->groupingSets,
1490 &qry->targetList,
1491 qry->sortClause,
1492 EXPR_KIND_GROUP_BY,
1493 false /* allow SQL92 rules */ );
1495
1497 {
1499 qry->hasDistinctOn = false;
1500 }
1502 {
1503 /* We had SELECT DISTINCT */
1505 &qry->targetList,
1506 qry->sortClause,
1507 false);
1508 qry->hasDistinctOn = false;
1509 }
1510 else
1511 {
1512 /* We had SELECT DISTINCT ON */
1514 stmt->distinctClause,
1515 &qry->targetList,
1516 qry->sortClause);
1517 qry->hasDistinctOn = true;
1518 }
1519
1520 /* transform LIMIT */
1523 stmt->limitOption);
1526 stmt->limitOption);
1528
1529 /* transform window clauses after we have seen all window functions */
1531 pstate->p_windowdefs,
1532 &qry->targetList);
1533
1534 /* resolve any still-unresolved output columns as being type text */
1537
1539 qry->rteperminfos = pstate->p_rteperminfos;
1541
1542 qry->hasSubLinks = pstate->p_hasSubLinks;
1543 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
1544 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
1545 qry->hasAggs = pstate->p_hasAggs;
1546
1548 {
1549 transformLockingClause(pstate, qry,
1551 }
1552
1553 assign_query_collations(pstate, qry);
1554
1555 /* this must be done after collations, for reliable comparison of exprs */
1557 parseCheckAggregates(pstate, qry);
1558
1559 return qry;
1560}
References assign_query_collations(), CMD_SELECT, Query::commandType, Query::cteList, Query::distinctClause, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_GROUP_BY, EXPR_KIND_HAVING, EXPR_KIND_LIMIT, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_SELECT_TARGET, EXPR_KIND_WHERE, exprLocation(), Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, Query::jointree, lfirst, Query::limitCount, Query::limitOffset, Query::limitOption, linitial, makeFromExpr(), makeNode, markTargetListOrigins(), NIL, ParseState::p_hasAggs, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseState::p_locking_clause, ParseState::p_resolve_unknowns, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_windowdefs, parseCheckAggregates(), parser_errposition(), resolveTargetListUnknowns(), Query::rtable, Query::sortClause, stmt, Query::targetList, transformDistinctClause(), transformDistinctOnClause(), transformFromClause(), transformGroupClause(), transformLimitClause(), transformLockingClause(), transformSortClause(), transformTargetList(), transformWhereClause(), transformWindowDefinitions(), transformWithClause(), and Query::windowClause.
Referenced by transformStmt().
◆ transformSetOperationStmt()
|
static |
Definition at line 1789 of file analyze.c.
1790{
1792 SelectStmt *leftmostSelect;
1793 int leftmostRTI;
1794 Query *leftmostQuery;
1795 SetOperationStmt *sostmt;
1796 List *sortClause;
1797 Node *limitOffset;
1798 Node *limitCount;
1799 List *lockingClause;
1800 WithClause *withClause;
1801 Node *node;
1802 ListCell *left_tlist,
1803 *lct,
1804 *lcm,
1805 *lcc,
1806 *l;
1807 List *targetvars,
1808 *targetnames,
1809 *sv_namespace;
1810 int sv_rtable_length;
1811 ParseNamespaceItem *jnsitem;
1812 ParseNamespaceColumn *sortnscolumns;
1813 int sortcolindex;
1814 int tllen;
1815
1817
1818 /*
1819 * Find leftmost leaf SelectStmt. We currently only need to do this in
1820 * order to deliver a suitable error message if there's an INTO clause
1821 * there, implying the set-op tree is in a context that doesn't allow
1822 * INTO. (transformSetOperationTree would throw error anyway, but it
1823 * seems worth the trouble to throw a different error for non-leftmost
1824 * INTO, so we produce that error in transformSetOperationTree.)
1825 */
1826 leftmostSelect = stmt->larg;
1828 leftmostSelect = leftmostSelect->larg;
1830 leftmostSelect->larg == NULL);
1833 (errcode(ERRCODE_SYNTAX_ERROR),
1835 parser_errposition(pstate,
1837
1838 /*
1839 * We need to extract ORDER BY and other top-level clauses here and not
1840 * let transformSetOperationTree() see them --- else it'll just recurse
1841 * right back here!
1842 */
1843 sortClause = stmt->sortClause;
1844 limitOffset = stmt->limitOffset;
1845 limitCount = stmt->limitCount;
1846 lockingClause = stmt->lockingClause;
1847 withClause = stmt->withClause;
1848
1850 stmt->limitOffset = NULL;
1851 stmt->limitCount = NULL;
1853 stmt->withClause = NULL;
1854
1855 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
1856 if (lockingClause)
1858 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1859 /*------
1860 translator: %s is a SQL row locking clause such as FOR UPDATE */
1863 linitial(lockingClause))->strength))));
1864
1865 /* Process the WITH clause independently of all else */
1866 if (withClause)
1867 {
1868 qry->hasRecursive = withClause->recursive;
1870 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1871 }
1872
1873 /*
1874 * Recursively transform the components of the tree.
1875 */
1878 Assert(sostmt);
1880
1881 /*
1882 * Re-find leftmost SELECT (now it's a sub-query in rangetable)
1883 */
1884 node = sostmt->larg;
1886 node = ((SetOperationStmt *) node)->larg;
1888 leftmostRTI = ((RangeTblRef *) node)->rtindex;
1890 Assert(leftmostQuery != NULL);
1891
1892 /*
1893 * Generate dummy targetlist for outer query using column names of
1894 * leftmost select and common datatypes/collations of topmost set
1895 * operation. Also make lists of the dummy vars and their names for use
1896 * in parsing ORDER BY.
1897 *
1898 * Note: we use leftmostRTI as the varno of the dummy variables. It
1899 * shouldn't matter too much which RT index they have, as long as they
1900 * have one that corresponds to a real RT entry; else funny things may
1901 * happen when the tree is mashed by rule rewriting.
1902 */
1904 targetvars = NIL;
1905 targetnames = NIL;
1906 sortnscolumns = (ParseNamespaceColumn *)
1908 sortcolindex = 0;
1909
1910 forfour(lct, sostmt->colTypes,
1911 lcm, sostmt->colTypmods,
1912 lcc, sostmt->colCollations,
1913 left_tlist, leftmostQuery->targetList)
1914 {
1919 char *colName;
1920 TargetEntry *tle;
1921 Var *var;
1922
1923 Assert(!lefttle->resjunk);
1924 colName = pstrdup(lefttle->resname);
1925 var = makeVar(leftmostRTI,
1926 lefttle->resno,
1927 colType,
1928 colTypmod,
1929 colCollation,
1930 0);
1934 colName,
1935 false);
1937 targetvars = lappend(targetvars, var);
1939 sortnscolumns[sortcolindex].p_varno = leftmostRTI;
1941 sortnscolumns[sortcolindex].p_vartype = colType;
1942 sortnscolumns[sortcolindex].p_vartypmod = colTypmod;
1943 sortnscolumns[sortcolindex].p_varcollid = colCollation;
1944 sortnscolumns[sortcolindex].p_varnosyn = leftmostRTI;
1946 sortcolindex++;
1947 }
1948
1949 /*
1950 * As a first step towards supporting sort clauses that are expressions
1951 * using the output columns, generate a namespace entry that makes the
1952 * output columns visible. A Join RTE node is handy for this, since we
1953 * can easily control the Vars generated upon matches.
1954 *
1955 * Note: we don't yet do anything useful with such cases, but at least
1956 * "ORDER BY upper(foo)" will draw the right error message rather than
1957 * "foo not found".
1958 */
1960
1961 jnsitem = addRangeTableEntryForJoin(pstate,
1962 targetnames,
1963 sortnscolumns,
1964 JOIN_INNER,
1965 0,
1966 targetvars,
1967 NIL,
1968 NIL,
1969 NULL,
1970 NULL,
1971 false);
1972
1973 sv_namespace = pstate->p_namespace;
1975
1976 /* add jnsitem to column namespace only */
1978
1979 /*
1980 * For now, we don't support resjunk sort clauses on the output of a
1981 * setOperation tree --- you can only use the SQL92-spec options of
1982 * selecting an output column by name or number. Enforce by checking that
1983 * transformSortClause doesn't add any items to tlist. Note, if changing
1984 * this, add_setop_child_rel_equivalences() will need to be updated.
1985 */
1987
1989 sortClause,
1990 &qry->targetList,
1991 EXPR_KIND_ORDER_BY,
1992 false /* allow SQL92 rules */ );
1993
1994 /* restore namespace, remove join RTE from rtable */
1995 pstate->p_namespace = sv_namespace;
1997
2000 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2004 parser_errposition(pstate,
2006
2009 stmt->limitOption);
2012 stmt->limitOption);
2014
2016 qry->rteperminfos = pstate->p_rteperminfos;
2018
2019 qry->hasSubLinks = pstate->p_hasSubLinks;
2020 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
2021 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2022 qry->hasAggs = pstate->p_hasAggs;
2023
2024 foreach(l, lockingClause)
2025 {
2026 transformLockingClause(pstate, qry,
2028 }
2029
2030 assign_query_collations(pstate, qry);
2031
2032 /* this must be done after collations, for reliable comparison of exprs */
2034 parseCheckAggregates(pstate, qry);
2035
2036 return qry;
2037}
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)
Definition: parse_relation.c:2229
static Node * transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, bool isTopLevel, List **targetlist)
Definition: analyze.c:2094
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
Definition: pg_list.h:575
Definition: parsenodes.h:1602
References addNSItemToQuery(), addRangeTableEntryForJoin(), Assert, assign_query_collations(), castNode, CMD_SELECT, Query::commandType, Query::cteList, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, TargetEntry::expr, EXPR_KIND_LIMIT, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, exprLocation(), forfour, Query::groupClause, Query::groupingSets, Query::havingQual, SelectStmt::intoClause, IsA, JOIN_INNER, Query::jointree, lappend(), SelectStmt::larg, SetOperationStmt::larg, LCS_asString(), lfirst, lfirst_int, lfirst_oid, Query::limitCount, Query::limitOffset, Query::limitOption, linitial, list_length(), list_nth(), list_truncate(), Var::location, makeFromExpr(), makeNode, makeString(), makeTargetEntry(), makeVar(), NIL, SelectStmt::op, ParseState::p_hasAggs, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseState::p_namespace, ParseState::p_next_resno, ParseState::p_rtable, ParseState::p_rteperminfos, ParseNamespaceColumn::p_varattno, ParseNamespaceColumn::p_varattnosyn, ParseNamespaceColumn::p_varcollid, ParseNamespaceColumn::p_varno, ParseNamespaceColumn::p_varnosyn, ParseNamespaceColumn::p_vartype, ParseNamespaceColumn::p_vartypmod, palloc0(), parseCheckAggregates(), parser_errposition(), pstrdup(), WithClause::recursive, TargetEntry::resno, rt_fetch, Query::rtable, SETOP_NONE, Query::setOperations, Query::sortClause, stmt, Query::targetList, transformLimitClause(), transformLockingClause(), transformSetOperationTree(), transformSortClause(), and transformWithClause().
Referenced by transformStmt().
◆ transformSetOperationTree()
|
static |
Definition at line 2094 of file analyze.c.
2096{
2097 bool isLeaf;
2098
2100
2101 /* Guard against stack overflow due to overly complex set-expressions */
2102 check_stack_depth();
2103
2104 /*
2105 * Validity-check both leaf and internal SELECTs for disallowed ops.
2106 */
2109 (errcode(ERRCODE_SYNTAX_ERROR),
2111 parser_errposition(pstate,
2113
2114 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
2117 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2118 /*------
2119 translator: %s is a SQL row locking clause such as FOR UPDATE */
2123
2124 /*
2125 * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE,
2126 * or WITH clauses attached, we need to treat it like a leaf node to
2127 * generate an independent sub-Query tree. Otherwise, it can be
2128 * represented by a SetOperationStmt node underneath the parent Query.
2129 */
2131 {
2133 isLeaf = true;
2134 }
2135 else
2136 {
2140 isLeaf = true;
2141 else
2142 isLeaf = false;
2143 }
2144
2145 if (isLeaf)
2146 {
2147 /* Process leaf SELECT */
2148 Query *selectQuery;
2149 char selectName[32];
2150 ParseNamespaceItem *nsitem;
2151 RangeTblRef *rtr;
2152 ListCell *tl;
2153
2154 /*
2155 * Transform SelectStmt into a Query.
2156 *
2157 * This works the same as SELECT transformation normally would, except
2158 * that we prevent resolving unknown-type outputs as TEXT. This does
2159 * not change the subquery's semantics since if the column type
2160 * matters semantically, it would have been resolved to something else
2161 * anyway. Doing this lets us resolve such outputs using
2162 * select_common_type(), below.
2163 *
2164 * Note: previously transformed sub-queries don't affect the parsing
2165 * of this sub-query, because they are not in the toplevel pstate's
2166 * namespace list.
2167 */
2169 NULL, false, false);
2170
2171 /*
2172 * Check for bogus references to Vars on the current query level (but
2173 * upper-level references are okay). Normally this can't happen
2174 * because the namespace will be empty, but it could happen if we are
2175 * inside a rule.
2176 */
2178 {
2181 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2182 errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
2183 parser_errposition(pstate,
2185 }
2186
2187 /*
2188 * Extract a list of the non-junk TLEs for upper-level processing.
2189 */
2190 if (targetlist)
2191 {
2192 *targetlist = NIL;
2193 foreach(tl, selectQuery->targetList)
2194 {
2196
2197 if (!tle->resjunk)
2198 *targetlist = lappend(*targetlist, tle);
2199 }
2200 }
2201
2202 /*
2203 * Make the leaf query be a subquery in the top-level rangetable.
2204 */
2207 nsitem = addRangeTableEntryForSubquery(pstate,
2208 selectQuery,
2210 false,
2211 false);
2212
2213 /*
2214 * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
2215 */
2219 }
2220 else
2221 {
2222 /* Process an internal node (set operation node) */
2224 List *ltargetlist;
2225 List *rtargetlist;
2226 ListCell *ltl;
2227 ListCell *rtl;
2228 const char *context;
2230 pstate->p_parent_cte->cterecursive);
2231
2234 "EXCEPT"));
2235
2238
2239 /*
2240 * Recursively transform the left child node.
2241 */
2243 false,
2244 <argetlist);
2245
2246 /*
2247 * If we are processing a recursive union query, now is the time to
2248 * examine the non-recursive term's output columns and mark the
2249 * containing CTE as having those result columns. We should do this
2250 * only at the topmost setop of the CTE, of course.
2251 */
2252 if (isTopLevel && recursive)
2254
2255 /*
2256 * Recursively transform the right child node.
2257 */
2259 false,
2260 &rtargetlist);
2261
2262 /*
2263 * Verify that the two children have the same number of non-junk
2264 * columns, and determine the types of the merged output columns.
2265 */
2268 (errcode(ERRCODE_SYNTAX_ERROR),
2270 context),
2271 parser_errposition(pstate,
2273
2274 if (targetlist)
2275 *targetlist = NIL;
2276 op->colTypes = NIL;
2277 op->colTypmods = NIL;
2278 op->colCollations = NIL;
2279 op->groupClauses = NIL;
2280 forboth(ltl, ltargetlist, rtl, rtargetlist)
2281 {
2288 Node *bestexpr;
2289 int bestlocation;
2290 Oid rescoltype;
2291 int32 rescoltypmod;
2292 Oid rescolcoll;
2293
2294 /* select common type, same as CASE et al */
2295 rescoltype = select_common_type(pstate,
2296 list_make2(lcolnode, rcolnode),
2297 context,
2298 &bestexpr);
2299 bestlocation = exprLocation(bestexpr);
2300
2301 /*
2302 * Verify the coercions are actually possible. If not, we'd fail
2303 * later anyway, but we want to fail now while we have sufficient
2304 * context to produce an error cursor position.
2305 *
2306 * For all non-UNKNOWN-type cases, we verify coercibility but we
2307 * don't modify the child's expression, for fear of changing the
2308 * child query's semantics.
2309 *
2310 * If a child expression is an UNKNOWN-type Const or Param, we
2311 * want to replace it with the coerced expression. This can only
2312 * happen when the child is a leaf set-op node. It's safe to
2313 * replace the expression because if the child query's semantics
2314 * depended on the type of this output column, it'd have already
2315 * coerced the UNKNOWN to something else. We want to do this
2316 * because (a) we want to verify that a Const is valid for the
2317 * target type, or resolve the actual type of an UNKNOWN Param,
2318 * and (b) we want to avoid unnecessary discrepancies between the
2319 * output type of the child query and the resolved target type.
2320 * Such a discrepancy would disable optimization in the planner.
2321 *
2322 * If it's some other UNKNOWN-type node, eg a Var, we do nothing
2323 * (knowing that coerce_to_common_type would fail). The planner
2324 * is sometimes able to fold an UNKNOWN Var to a constant before
2325 * it has to coerce the type, so failing now would just break
2326 * cases that might work.
2327 */
2328 if (lcoltype != UNKNOWNOID)
2329 lcolnode = coerce_to_common_type(pstate, lcolnode,
2330 rescoltype, context);
2333 {
2334 lcolnode = coerce_to_common_type(pstate, lcolnode,
2335 rescoltype, context);
2337 }
2338
2339 if (rcoltype != UNKNOWNOID)
2340 rcolnode = coerce_to_common_type(pstate, rcolnode,
2341 rescoltype, context);
2344 {
2345 rcolnode = coerce_to_common_type(pstate, rcolnode,
2346 rescoltype, context);
2348 }
2349
2350 rescoltypmod = select_common_typmod(pstate,
2351 list_make2(lcolnode, rcolnode),
2352 rescoltype);
2353
2354 /*
2355 * Select common collation. A common collation is required for
2356 * all set operators except UNION ALL; see SQL:2008 7.13 <query
2357 * expression> Syntax Rule 15c. (If we fail to identify a common
2358 * collation for a UNION ALL column, the colCollations element
2359 * will be set to InvalidOid, which may result in a runtime error
2360 * if something at a higher query level wants to use the column's
2361 * collation.)
2362 */
2363 rescolcoll = select_common_collation(pstate,
2364 list_make2(lcolnode, rcolnode),
2366
2367 /* emit results */
2368 op->colTypes = lappend_oid(op->colTypes, rescoltype);
2369 op->colTypmods = lappend_int(op->colTypmods, rescoltypmod);
2370 op->colCollations = lappend_oid(op->colCollations, rescolcoll);
2371
2372 /*
2373 * For all cases except UNION ALL, identify the grouping operators
2374 * (and, if available, sorting operators) that will be used to
2375 * eliminate duplicates.
2376 */
2378 {
2379 ParseCallbackState pcbstate;
2380
2381 setup_parser_errposition_callback(&pcbstate, pstate,
2382 bestlocation);
2383
2384 /*
2385 * If it's a recursive union, we need to require hashing
2386 * support.
2387 */
2388 op->groupClauses = lappend(op->groupClauses,
2389 makeSortGroupClauseForSetOp(rescoltype, recursive));
2390
2391 cancel_parser_errposition_callback(&pcbstate);
2392 }
2393
2394 /*
2395 * Construct a dummy tlist entry to return. We use a SetToDefault
2396 * node for the expression, since it carries exactly the fields
2397 * needed, but any other expression node type would do as well.
2398 */
2399 if (targetlist)
2400 {
2402 TargetEntry *restle;
2403
2404 rescolnode->typeId = rescoltype;
2405 rescolnode->typeMod = rescoltypmod;
2406 rescolnode->collation = rescolcoll;
2407 rescolnode->location = bestlocation;
2409 0, /* no need to set resno */
2410 NULL,
2411 false);
2412 *targetlist = lappend(*targetlist, restle);
2413 }
2414 }
2415
2417 }
2418}
Node * coerce_to_common_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *context)
Definition: parse_coerce.c:1537
int32 select_common_typmod(ParseState *pstate, List *exprs, Oid common_type)
Definition: parse_coerce.c:1609
Oid select_common_type(ParseState *pstate, List *exprs, const char *context, Node **which_expr)
Definition: parse_coerce.c:1307
Oid select_common_collation(ParseState *pstate, List *exprs, bool none_ok)
Definition: parse_collate.c:208
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition: parse_node.c:156
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition: parse_node.c:140
SortGroupClause * makeSortGroupClauseForSetOp(Oid rescoltype, bool require_hash)
Definition: analyze.c:2046
static void determineRecursiveColTypes(ParseState *pstate, Node *larg, List *nrtargetlist)
Definition: analyze.c:2425
Query * parse_sub_analyze(Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
Definition: analyze.c:222
Definition: parse_node.h:359
Definition: primnodes.h:2100
References addRangeTableEntryForSubquery(), SetOperationStmt::all, Assert, cancel_parser_errposition_callback(), check_stack_depth(), coerce_to_common_type(), contain_vars_of_level(), determineRecursiveColTypes(), ereport, errcode(), errmsg(), ERROR, TargetEntry::expr, exprLocation(), exprType(), forboth, IsA, lappend(), lappend_int(), lappend_oid(), SetOperationStmt::larg, LCS_asString(), lfirst, linitial, list_length(), list_make2, locate_var_of_level(), SetToDefault::location, makeAlias(), makeNode, makeSortGroupClauseForSetOp(), makeTargetEntry(), NIL, SetOperationStmt::op, ParseState::p_namespace, ParseState::p_parent_cte, ParseState::p_rtable, ParseNamespaceItem::p_rtindex, parse_sub_analyze(), parser_errposition(), SetOperationStmt::rarg, RangeTblRef::rtindex, select_common_collation(), select_common_type(), select_common_typmod(), SETOP_INTERSECT, SETOP_NONE, SETOP_UNION, setup_parser_errposition_callback(), snprintf, stmt, Query::targetList, transformSetOperationTree(), and SetToDefault::typeId.
Referenced by transformSetOperationStmt(), and transformSetOperationTree().
◆ transformStmt()
| Query * transformStmt | ( | ParseState * | pstate, |
| Node * | parseTree | ||
| ) |
Definition at line 396 of file analyze.c.
397{
398 Query *result;
399
400#ifdef DEBUG_NODE_TESTS_ENABLED
401
402 /*
403 * We apply debug_raw_expression_coverage_test testing to basic DML
404 * statements; we can't just run it on everything because
405 * raw_expression_tree_walker() doesn't claim to handle utility
406 * statements.
407 */
408 if (Debug_raw_expression_coverage_test)
409 {
411 {
412 case T_SelectStmt:
413 case T_InsertStmt:
414 case T_UpdateStmt:
415 case T_DeleteStmt:
416 case T_MergeStmt:
417 (void) test_raw_expression_coverage(parseTree, NULL);
418 break;
419 default:
420 break;
421 }
422 }
423#endif /* DEBUG_NODE_TESTS_ENABLED */
424
425 /*
426 * Caution: when changing the set of statement types that have non-default
427 * processing here, see also stmt_requires_parse_analysis() and
428 * analyze_requires_snapshot().
429 */
431 {
432 /*
433 * Optimizable statements
434 */
435 case T_InsertStmt:
437 break;
438
439 case T_DeleteStmt:
441 break;
442
443 case T_UpdateStmt:
445 break;
446
447 case T_MergeStmt:
449 break;
450
451 case T_SelectStmt:
452 {
454
456 result = transformValuesClause(pstate, n);
458 result = transformSelectStmt(pstate, n);
459 else
460 result = transformSetOperationStmt(pstate, n);
461 }
462 break;
463
464 case T_ReturnStmt:
466 break;
467
468 case T_PLAssignStmt:
469 result = transformPLAssignStmt(pstate,
470 (PLAssignStmt *) parseTree);
471 break;
472
473 /*
474 * Special cases
475 */
476 case T_DeclareCursorStmt:
477 result = transformDeclareCursorStmt(pstate,
478 (DeclareCursorStmt *) parseTree);
479 break;
480
481 case T_ExplainStmt:
482 result = transformExplainStmt(pstate,
483 (ExplainStmt *) parseTree);
484 break;
485
486 case T_CreateTableAsStmt:
487 result = transformCreateTableAsStmt(pstate,
488 (CreateTableAsStmt *) parseTree);
489 break;
490
491 case T_CallStmt:
492 result = transformCallStmt(pstate,
493 (CallStmt *) parseTree);
494 break;
495
496 default:
497
498 /*
499 * other statements don't require any transformation; just return
500 * the original parsetree with a Query node plastered on top.
501 */
505 break;
506 }
507
508 /* Mark as original query until we learn differently */
509 result->querySource = QSRC_ORIGINAL;
510 result->canSetTag = true;
511 setQueryLocationAndLength(pstate, result, parseTree);
512
513 return result;
514}
Query * transformMergeStmt(ParseState *pstate, MergeStmt *stmt)
Definition: parse_merge.c:107
static void setQueryLocationAndLength(ParseState *pstate, Query *qry, Node *parseTree)
Definition: analyze.c:259
static Query * transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
Definition: analyze.c:599
static Query * transformReturnStmt(ParseState *pstate, ReturnStmt *stmt)
Definition: analyze.c:2479
static Query * transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt)
Definition: analyze.c:2813
static Query * transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt)
Definition: analyze.c:3207
static Query * transformCallStmt(ParseState *pstate, CallStmt *stmt)
Definition: analyze.c:3282
static Query * transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1789
static Query * transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
Definition: analyze.c:2510
static Query * transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1427
static Query * transformExplainStmt(ParseState *pstate, ExplainStmt *stmt)
Definition: analyze.c:3155
static Query * transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
Definition: analyze.c:3062
static Query * transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
Definition: analyze.c:671
static Query * transformValuesClause(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1570
Definition: parsenodes.h:3578
Definition: parsenodes.h:3367
Definition: parsenodes.h:3944
Definition: parsenodes.h:2265
References CMD_UTILITY, Query::commandType, makeNode, nodeTag, SelectStmt::op, QSRC_ORIGINAL, SETOP_NONE, setQueryLocationAndLength(), transformCallStmt(), transformCreateTableAsStmt(), transformDeclareCursorStmt(), transformDeleteStmt(), transformExplainStmt(), transformInsertStmt(), transformMergeStmt(), transformPLAssignStmt(), transformReturnStmt(), transformSelectStmt(), transformSetOperationStmt(), transformUpdateStmt(), transformValuesClause(), Query::utilityStmt, and SelectStmt::valuesLists.
Referenced by interpret_AS_clause(), parse_sub_analyze(), transformCreateTableAsStmt(), transformDeclareCursorStmt(), transformInsertStmt(), transformJsonArrayQueryConstructor(), transformOptionalSelectInto(), and transformRuleStmt().
◆ transformTopLevelStmt()
| Query * transformTopLevelStmt | ( | ParseState * | pstate, |
| RawStmt * | parseTree | ||
| ) |
Definition at line 332 of file analyze.c.
333{
334 Query *result;
335
336 /* Store RawStmt's length and location in pstate */
339
340 /* We're at top level, so allow SELECT INTO */
342
343 return result;
344}
References ParseState::p_stmt_len, ParseState::p_stmt_location, RawStmt::stmt, RawStmt::stmt_len, RawStmt::stmt_location, and transformOptionalSelectInto().
Referenced by inline_function(), parse_analyze_fixedparams(), parse_analyze_varparams(), and parse_analyze_withcb().
◆ transformUpdateStmt()
|
static |
Definition at line 2510 of file analyze.c.
2511{
2513 ParseNamespaceItem *nsitem;
2514 Node *qual;
2515
2518
2519 /* process the WITH clause independently of all else */
2521 {
2522 qry->hasRecursive = stmt->withClause->recursive;
2524 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
2525 }
2526
2528 stmt->relation->inh,
2529 true,
2530 ACL_UPDATE);
2531 nsitem = pstate->p_target_nsitem;
2532
2533 /* subqueries in FROM cannot access the result relation */
2536
2537 /*
2538 * the FROM clause is non-standard SQL syntax. We used to be able to do
2539 * this with REPLACE in POSTQUEL so we keep the feature.
2540 */
2542
2543 /* remaining clauses can reference the result relation normally */
2546
2549
2551 EXPR_KIND_RETURNING);
2552
2553 /*
2554 * Now we are done with SELECT-like processing, and can get on with
2555 * transforming the target list to match the UPDATE target columns.
2556 */
2558
2560 qry->rteperminfos = pstate->p_rteperminfos;
2562
2563 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2564 qry->hasSubLinks = pstate->p_hasSubLinks;
2565
2566 assign_query_collations(pstate, qry);
2567
2568 return qry;
2569}
References ACL_UPDATE, assign_query_collations(), CMD_UPDATE, Query::commandType, Query::cteList, EXPR_KIND_RETURNING, EXPR_KIND_WHERE, Query::jointree, makeFromExpr(), makeNode, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_is_insert, ParseState::p_joinlist, ParseNamespaceItem::p_lateral_ok, ParseNamespaceItem::p_lateral_only, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_target_nsitem, Query::rtable, setTargetTable(), stmt, Query::targetList, transformFromClause(), transformReturningClause(), transformUpdateTargetList(), transformWhereClause(), and transformWithClause().
Referenced by transformStmt().
◆ transformUpdateTargetList()
| List * transformUpdateTargetList | ( | ParseState * | pstate, |
| List * | origTlist | ||
| ) |
Definition at line 2576 of file analyze.c.
2577{
2579 RTEPermissionInfo *target_perminfo;
2580 ListCell *orig_tl;
2581 ListCell *tl;
2582
2583 tlist = transformTargetList(pstate, origTlist,
2584 EXPR_KIND_UPDATE_SOURCE);
2585
2586 /* Prepare to assign non-conflicting resnos to resjunk attributes */
2589
2590 /* Prepare non-junk columns for assignment to target table */
2592 orig_tl = list_head(origTlist);
2593
2594 foreach(tl, tlist)
2595 {
2597 ResTarget *origTarget;
2598 int attrno;
2599
2600 if (tle->resjunk)
2601 {
2602 /*
2603 * Resjunk nodes need no additional processing, but be sure they
2604 * have resnos that do not match any target columns; else rewriter
2605 * or planner might get confused. They don't need a resname
2606 * either.
2607 */
2609 tle->resname = NULL;
2610 continue;
2611 }
2612 if (orig_tl == NULL)
2615
2620 (errcode(ERRCODE_UNDEFINED_COLUMN),
2622 origTarget->name,
2628
2630 attrno,
2631 origTarget->indirection,
2632 origTarget->location);
2633
2634 /* Mark the target column as requiring update permissions */
2636 attrno - FirstLowInvalidHeapAttributeNumber);
2637
2638 orig_tl = lnext(origTlist, orig_tl);
2639 }
2640 if (orig_tl != NULL)
2642
2643 return tlist;
2644}
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
Definition: parse_relation.c:3585
void updateTargetListEntry(ParseState *pstate, TargetEntry *tle, char *colname, int attrno, List *indirection, int location)
Definition: parse_target.c:622
References Alias::aliasname, attnameAttNum(), bms_add_member(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_UPDATE_SOURCE, FirstLowInvalidHeapAttributeNumber, ResTarget::indirection, InvalidAttrNumber, lfirst, lfirst_node, list_head(), lnext(), ResTarget::location, ResTarget::name, NIL, ParseNamespaceItem::p_names, ParseState::p_next_resno, ParseNamespaceItem::p_perminfo, ParseState::p_target_nsitem, ParseState::p_target_relation, parser_errposition(), RelationGetNumberOfAttributes, RelationGetRelationName, TargetEntry::resno, transformTargetList(), RTEPermissionInfo::updatedCols, and updateTargetListEntry().
Referenced by transformMergeStmt(), transformOnConflictClause(), and transformUpdateStmt().
◆ transformValuesClause()
|
static |
Definition at line 1570 of file analyze.c.
1571{
1577 List **colexprs = NULL;
1578 int sublist_length = -1;
1579 bool lateral = false;
1580 ParseNamespaceItem *nsitem;
1581 ListCell *lc;
1582 ListCell *lc2;
1584
1586
1587 /* Most SELECT stuff doesn't apply in a VALUES clause */
1597
1598 /* process the WITH clause independently of all else */
1600 {
1601 qry->hasRecursive = stmt->withClause->recursive;
1603 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1604 }
1605
1606 /*
1607 * For each row of VALUES, transform the raw expressions.
1608 *
1609 * Note that the intermediate representation we build is column-organized
1610 * not row-organized. That simplifies the type and collation processing
1611 * below.
1612 */
1614 {
1616
1617 /*
1618 * Do basic expression transformation (same as a ROW() expr, but here
1619 * we disallow SetToDefault)
1620 */
1621 sublist = transformExpressionList(pstate, sublist,
1623
1624 /*
1625 * All the sublists must be the same length, *after* transformation
1626 * (which might expand '*' into multiple items). The VALUES RTE can't
1627 * handle anything different.
1628 */
1629 if (sublist_length < 0)
1630 {
1631 /* Remember post-transformation length of first sublist */
1632 sublist_length = list_length(sublist);
1633 /* and allocate array for per-column lists */
1635 }
1637 {
1639 (errcode(ERRCODE_SYNTAX_ERROR),
1641 parser_errposition(pstate,
1643 }
1644
1645 /* Build per-column expression lists */
1646 i = 0;
1647 foreach(lc2, sublist)
1648 {
1650
1652 i++;
1653 }
1654
1655 /* Release sub-list's cells to save memory */
1656 list_free(sublist);
1657
1658 /* Prepare an exprsLists element for this row */
1660 }
1661
1662 /*
1663 * Now resolve the common types of the columns, and coerce everything to
1664 * those types. Then identify the common typmod and common collation, if
1665 * any, of each column.
1666 *
1667 * We must do collation processing now because (1) assign_query_collations
1668 * doesn't process rangetable entries, and (2) we need to label the VALUES
1669 * RTE with column collations for use in the outer query. We don't
1670 * consider conflict of implicit collations to be an error here; instead
1671 * the column will just show InvalidOid as its collation, and you'll get a
1672 * failure later if that results in failure to resolve a collation.
1673 *
1674 * Note we modify the per-column expression lists in-place.
1675 */
1677 {
1678 Oid coltype;
1679 int32 coltypmod;
1680 Oid colcoll;
1681
1683
1685 {
1687
1689 lfirst(lc) = col;
1690 }
1691
1694
1695 coltypes = lappend_oid(coltypes, coltype);
1696 coltypmods = lappend_int(coltypmods, coltypmod);
1697 colcollations = lappend_oid(colcollations, colcoll);
1698 }
1699
1700 /*
1701 * Finally, rearrange the coerced expressions into row-organized lists.
1702 */
1704 {
1706 {
1709
1710 sublist = lappend(sublist, col);
1711 lfirst(lc2) = sublist;
1712 }
1714 }
1715
1716 /*
1717 * Ordinarily there can't be any current-level Vars in the expression
1718 * lists, because the namespace was empty ... but if we're inside CREATE
1719 * RULE, then NEW/OLD references might appear. In that case we have to
1720 * mark the VALUES RTE as LATERAL.
1721 */
1724 lateral = true;
1725
1726 /*
1727 * Generate the VALUES RTE
1728 */
1729 nsitem = addRangeTableEntryForValues(pstate, exprsLists,
1730 coltypes, coltypmods, colcollations,
1731 NULL, lateral, true);
1733
1734 /*
1735 * Generate a targetlist as though expanding "*"
1736 */
1739
1740 /*
1741 * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a
1742 * VALUES, so cope.
1743 */
1745 stmt->sortClause,
1746 &qry->targetList,
1747 EXPR_KIND_ORDER_BY,
1748 false /* allow SQL92 rules */ );
1749
1752 stmt->limitOption);
1755 stmt->limitOption);
1757
1760 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1761 /*------
1762 translator: %s is a SQL row locking clause such as FOR UPDATE */
1766
1768 qry->rteperminfos = pstate->p_rteperminfos;
1770
1771 qry->hasSubLinks = pstate->p_hasSubLinks;
1772
1773 assign_query_collations(pstate, qry);
1774
1775 return qry;
1776}
List * expandNSItemAttrs(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, bool require_col_privs, int location)
Definition: parse_relation.c:3288
References addNSItemToQuery(), addRangeTableEntryForValues(), Assert, assign_query_collations(), CMD_SELECT, coerce_to_common_type(), Query::commandType, contain_vars_of_level(), Query::cteList, ereport, errcode(), errmsg(), ERROR, expandNSItemAttrs(), EXPR_KIND_LIMIT, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_VALUES, exprLocation(), forboth, i, Query::jointree, lappend(), lappend_int(), lappend_oid(), LCS_asString(), lfirst, Query::limitCount, Query::limitOffset, Query::limitOption, linitial, list_free(), list_length(), makeFromExpr(), makeNode, NIL, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_joinlist, ParseState::p_next_resno, ParseState::p_rtable, ParseState::p_rteperminfos, palloc0(), parser_errposition(), Query::rtable, select_common_collation(), select_common_type(), select_common_typmod(), SETOP_NONE, Query::sortClause, stmt, Query::targetList, transformExpressionList(), transformLimitClause(), transformSortClause(), and transformWithClause().
Referenced by transformStmt().
Variable Documentation
◆ post_parse_analyze_hook
| post_parse_analyze_hook_type post_parse_analyze_hook = NULL |
Definition at line 59 of file analyze.c.
Referenced by _PG_init(), ExecCreateTableAs(), ExplainOneUtility(), ExplainQuery(), parse_analyze_fixedparams(), parse_analyze_varparams(), parse_analyze_withcb(), and PerformCursorOpen().
