#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 2685 of file analyze.c.
2687{
2688 List *colnames;
2689 int numattrs;
2690 ParseNamespaceColumn *nscolumns;
2691 ParseNamespaceItem *nsitem;
2692
2693 /* copy per-column data from the target relation */
2695 numattrs = list_length(colnames);
2696
2697 nscolumns = (ParseNamespaceColumn *)
2699
2702
2703 /* mark all columns as returning OLD/NEW */
2705 nscolumns[i].p_varreturningtype = returning_type;
2706
2707 /* build the nsitem, copying most fields from the target relation */
2713 nsitem->p_nscolumns = nscolumns;
2714 nsitem->p_returning_type = returning_type;
2715
2716 /* add it to the query namespace as a table-only item */
2718}
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
Definition: parse_relation.c:2710
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 571 of file analyze.c.
572{
573 /*
574 * Currently, this should return true in exactly the same cases that
575 * stmt_requires_parse_analysis() does, so we just invoke that function
576 * rather than duplicating it. We keep the two entry points separate for
577 * clarity of callers, since from the callers' standpoint these are
578 * different conditions.
579 *
580 * While there may someday be a statement type for which transformStmt()
581 * does something nontrivial and yet no snapshot is needed for that
582 * processing, it seems likely that making such a choice would be fragile.
583 * If you want to install an exception, document the reasoning for it in a
584 * comment.
585 */
587}
bool stmt_requires_parse_analysis(RawStmt *parseTree)
Definition: analyze.c:527
References stmt_requires_parse_analysis().
Referenced by BuildingPlanRequiresSnapshot(), 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 3757 of file analyze.c.
3760{
3761 RowMarkClause *rc;
3762
3764
3765 /* If it's an explicit clause, make sure hasForUpdate gets set */
3766 if (!pushedDown)
3767 qry->hasForUpdate = true;
3768
3769 /* Check for pre-existing entry for same rtindex */
3771 {
3772 /*
3773 * If the same RTE is specified with more than one locking strength,
3774 * use the strongest. (Reasonable, since you can't take both a shared
3775 * and exclusive lock at the same time; it'll end up being exclusive
3776 * anyway.)
3777 *
3778 * Similarly, if the same RTE is specified with more than one lock
3779 * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
3780 * turn wins over waiting for the lock (the default). This is a bit
3781 * more debatable but raising an error doesn't seem helpful. (Consider
3782 * for instance SELECT FOR UPDATE NOWAIT from a view that internally
3783 * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP
3784 * LOCKED is reasonable since the former throws an error in case of
3785 * coming across a locked tuple, which may be undesirable in some
3786 * cases but it seems better than silently returning inconsistent
3787 * results.
3788 *
3789 * And of course pushedDown becomes false if any clause is explicit.
3790 */
3793 rc->pushedDown &= pushedDown;
3794 return;
3795 }
3796
3797 /* Make a new RowMarkClause */
3799 rc->rti = rtindex;
3800 rc->strength = strength;
3801 rc->waitPolicy = waitPolicy;
3802 rc->pushedDown = pushedDown;
3804}
Assert(PointerIsAligned(start, uint64))
RowMarkClause * get_parse_rowmark(Query *qry, Index rtindex)
Definition: parse_relation.c:3565
Definition: parsenodes.h:1591
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 1349 of file analyze.c.
1351{
1353 int attno;
1354 Var *var;
1355 TargetEntry *te;
1356
1357 /*
1358 * Note that resnos of the tlist must correspond to attnos of the
1359 * underlying relation, hence we need entries for dropped columns too.
1360 */
1362 {
1365
1366 if (attr->attisdropped)
1367 {
1368 /*
1369 * can't use atttypid here, but it doesn't really matter what type
1370 * the Const claims to be.
1371 */
1373 name = NULL;
1374 }
1375 else
1376 {
1377 var = makeVar(exclRelIndex, attno + 1,
1378 attr->atttypid, attr->atttypmod,
1379 attr->attcollation,
1380 0);
1382 }
1383
1385 attno + 1,
1386 name,
1387 false);
1388
1389 result = lappend(result, te);
1390 }
1391
1392 /*
1393 * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like
1394 * the other entries in the EXCLUDED tlist, its resno must match the Var's
1395 * varattno, else the wrong things happen while resolving references in
1396 * setrefs.c. This is against normal conventions for targetlists, but
1397 * it's okay since we don't use this as a real tlist.
1398 */
1400 targetrel->rd_rel->reltype,
1401 -1, InvalidOid, 0);
1403 result = lappend(result, te);
1404
1405 return result;
1406}
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:388
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:289
Definition: primnodes.h:189
Definition: primnodes.h:2216
Definition: primnodes.h:262
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
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 3466 of file analyze.c.
3467{
3469
3472 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3473 /*------
3474 translator: %s is a SQL row locking clause such as FOR UPDATE */
3476 LCS_asString(strength))));
3479 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3480 /*------
3481 translator: %s is a SQL row locking clause such as FOR UPDATE */
3483 LCS_asString(strength))));
3486 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3487 /*------
3488 translator: %s is a SQL row locking clause such as FOR UPDATE */
3490 LCS_asString(strength))));
3493 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3494 /*------
3495 translator: %s is a SQL row locking clause such as FOR UPDATE */
3497 LCS_asString(strength))));
3498 if (qry->hasAggs)
3500 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3501 /*------
3502 translator: %s is a SQL row locking clause such as FOR UPDATE */
3504 LCS_asString(strength))));
3505 if (qry->hasWindowFuncs)
3507 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3508 /*------
3509 translator: %s is a SQL row locking clause such as FOR UPDATE */
3511 LCS_asString(strength))));
3512 if (qry->hasTargetSRFs)
3514 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3515 /*------
3516 translator: %s is a SQL row locking clause such as FOR UPDATE */
3518 LCS_asString(strength))));
3519}
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 1419 of file analyze.c.
1420{
1421 if (expr == NULL)
1422 return -1;
1426 {
1429
1431 {
1432 RangeTblEntry *rte;
1433
1436 {
1437 /* Subselect-in-FROM: examine sub-select's output expr */
1439 attnum);
1440
1441 if (ste == NULL || ste->resjunk)
1442 return -1;
1446 }
1447 }
1448 }
1449 return -1;
1450}
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition: parse_relation.c:3545
RangeTblEntry * GetRTEByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
Definition: parse_relation.c:545
Definition: nodes.h:135
Definition: parsenodes.h:1041
Definition: primnodes.h:1426
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 2459 of file analyze.c.
2460{
2461 Node *node;
2462 int leftmostRTI;
2463 Query *leftmostQuery;
2464 List *targetList;
2465 ListCell *left_tlist;
2466 ListCell *nrtl;
2467 int next_resno;
2468
2469 /*
2470 * Find leftmost leaf SELECT
2471 */
2472 node = larg;
2474 node = ((SetOperationStmt *) node)->larg;
2476 leftmostRTI = ((RangeTblRef *) node)->rtindex;
2478 Assert(leftmostQuery != NULL);
2479
2480 /*
2481 * Generate dummy targetlist using column names of leftmost select and
2482 * dummy result expressions of the non-recursive term.
2483 */
2484 targetList = NIL;
2485 next_resno = 1;
2486
2488 {
2491 char *colName;
2492 TargetEntry *tle;
2493
2494 Assert(!lefttle->resjunk);
2495 colName = pstrdup(lefttle->resname);
2497 next_resno++,
2498 colName,
2499 false);
2500 targetList = lappend(targetList, tle);
2501 }
2502
2503 /* Now build CTE's output column info using dummy targetlist */
2505}
void analyzeCTETargetList(ParseState *pstate, CommonTableExpr *cte, List *tlist)
Definition: parse_cte.c:571
Definition: parsenodes.h:118
Definition: primnodes.h:2273
Definition: parsenodes.h:2245
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 3441 of file analyze.c.
3442{
3443 switch (strength)
3444 {
3447 break;
3449 return "FOR KEY SHARE";
3451 return "FOR SHARE";
3453 return "FOR NO KEY UPDATE";
3455 return "FOR UPDATE";
3456 }
3457 return "FOR some"; /* shouldn't happen */
3458}
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 2080 of file analyze.c.
2081{
2083 Oid sortop;
2084 Oid eqop;
2085 bool hashable;
2086
2087 /* determine the eqop and optional sortop */
2088 get_sort_group_operators(rescoltype,
2089 false, true, false,
2090 &sortop, &eqop, NULL,
2091 &hashable);
2092
2093 /*
2094 * The type cache doesn't believe that record is hashable (see
2095 * cache_record_field_properties()), but if the caller really needs hash
2096 * support, we can assume it does. Worst case, if any components of the
2097 * record don't support hashing, we will fail at execution.
2098 */
2099 if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
2100 hashable = true;
2101
2102 /* we don't have a tlist yet, so can't assign sortgrouprefs */
2103 grpcl->tleSortGroupRef = 0;
2104 grpcl->eqop = eqop;
2105 grpcl->sortop = sortop;
2108 grpcl->hashable = hashable;
2109
2110 return grpcl;
2111}
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:1450
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:686
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:327
Definition: queryjumble.h:39
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().
◆ query_requires_rewrite_plan()
| bool query_requires_rewrite_plan | ( | Query * | query | ) |
Definition at line 600 of file analyze.c.
601{
602 bool result;
603
605 {
606 /* All optimizable statements require rewriting/planning */
607 result = true;
608 }
609 else
610 {
611 /* This list should match stmt_requires_parse_analysis() */
613 {
614 case T_DeclareCursorStmt:
615 case T_ExplainStmt:
616 case T_CreateTableAsStmt:
617 case T_CallStmt:
618 result = true;
619 break;
620 default:
621 result = false;
622 break;
623 }
624 }
625 return result;
626}
References CMD_UTILITY, Query::commandType, nodeTag, and Query::utilityStmt.
Referenced by BuildingPlanRequiresSnapshot(), and StmtPlanRequiresRevalidation().
◆ setQueryLocationAndLength()
|
static |
Definition at line 260 of file analyze.c.
261{
262 ParseLoc stmt_len = 0;
263
265 {
266 case T_InsertStmt:
268 stmt_len = ((InsertStmt *) parseTree)->stmt_len;
269 break;
270
271 case T_DeleteStmt:
273 stmt_len = ((DeleteStmt *) parseTree)->stmt_len;
274 break;
275
276 case T_UpdateStmt:
278 stmt_len = ((UpdateStmt *) parseTree)->stmt_len;
279 break;
280
281 case T_MergeStmt:
283 stmt_len = ((MergeStmt *) parseTree)->stmt_len;
284 break;
285
286 case T_SelectStmt:
288 stmt_len = ((SelectStmt *) parseTree)->stmt_len;
289 break;
290
291 case T_PLAssignStmt:
293 break;
294
295 default:
297 break;
298 }
299
300 if (stmt_len > 0)
301 {
302 /* Statement's length is known, use it */
303 qry->stmt_len = stmt_len;
304 }
306 {
307 /*
308 * The top RawStmt's length is known, so calculate the statement's
309 * length from the statement's location and the RawStmt's length and
310 * location.
311 */
313 }
314
315 /* The calculated statement length should be calculated as positive. */
316 Assert(qry->stmt_len >= 0);
317}
Definition: parsenodes.h:2107
Definition: parsenodes.h:2089
Definition: parsenodes.h:2140
Definition: parsenodes.h:2284
Definition: parsenodes.h:2174
Definition: parsenodes.h:2123
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 527 of file analyze.c.
528{
529 bool result;
530
532 {
533 /*
534 * Optimizable statements
535 */
536 case T_InsertStmt:
537 case T_DeleteStmt:
538 case T_UpdateStmt:
539 case T_MergeStmt:
540 case T_SelectStmt:
541 case T_ReturnStmt:
542 case T_PLAssignStmt:
543 result = true;
544 break;
545
546 /*
547 * Special cases
548 */
549 case T_DeclareCursorStmt:
550 case T_ExplainStmt:
551 case T_CreateTableAsStmt:
552 case T_CallStmt:
553 result = true;
554 break;
555
556 default:
557 /* all other statements just get wrapped in a CMD_UTILITY Query */
558 result = false;
559 break;
560 }
561
562 return result;
563}
References nodeTag, and RawStmt::stmt.
Referenced by analyze_requires_snapshot(), and StmtPlanRequiresRevalidation().
◆ transformCallStmt()
|
static |
Definition at line 3316 of file analyze.c.
3317{
3318 List *targs;
3319 ListCell *lc;
3320 Node *node;
3321 FuncExpr *fexpr;
3322 HeapTuple proctup;
3323 Datum proargmodes;
3324 bool isNull;
3326 Query *result;
3327
3328 /*
3329 * First, do standard parse analysis on the procedure call and its
3330 * arguments, allowing us to identify the called procedure.
3331 */
3332 targs = NIL;
3334 {
3337 EXPR_KIND_CALL_ARGUMENT));
3338 }
3339
3340 node = ParseFuncOrColumn(pstate,
3341 stmt->funccall->funcname,
3342 targs,
3343 pstate->p_last_srf,
3344 stmt->funccall,
3345 true,
3346 stmt->funccall->location);
3347
3348 assign_expr_collations(pstate, node);
3349
3351
3355
3356 /*
3357 * Expand the argument list to deal with named-argument notation and
3358 * default arguments. For ordinary FuncExprs this'd be done during
3359 * planning, but a CallStmt doesn't go through planning, and there seems
3360 * no good reason not to do it here.
3361 */
3363 true,
3364 fexpr->funcresulttype,
3365 proctup);
3366
3367 /* Fetch proargmodes; if it's null, there are no output args */
3368 proargmodes = SysCacheGetAttr(PROCOID, proctup,
3369 Anum_pg_proc_proargmodes,
3370 &isNull);
3371 if (!isNull)
3372 {
3373 /*
3374 * Split the list into input arguments in fexpr->args and output
3375 * arguments in stmt->outargs. INOUT arguments appear in both lists.
3376 */
3377 ArrayType *arr;
3378 int numargs;
3379 char *argmodes;
3380 List *inargs;
3382
3386 ARR_DIMS(arr)[0] != numargs ||
3387 ARR_HASNULL(arr) ||
3388 ARR_ELEMTYPE(arr) != CHAROID)
3390 numargs);
3392
3393 inargs = NIL;
3394 i = 0;
3396 {
3398
3400 {
3401 case PROARGMODE_IN:
3402 case PROARGMODE_VARIADIC:
3403 inargs = lappend(inargs, n);
3404 break;
3405 case PROARGMODE_OUT:
3406 outargs = lappend(outargs, n);
3407 break;
3408 case PROARGMODE_INOUT:
3409 inargs = lappend(inargs, n);
3411 break;
3412 default:
3413 /* note we don't support PROARGMODE_TABLE */
3415 argmodes[i]);
3416 break;
3417 }
3418 i++;
3419 }
3420 fexpr->args = inargs;
3421 }
3422
3423 stmt->funcexpr = fexpr;
3424 stmt->outargs = outargs;
3425
3426 ReleaseSysCache(proctup);
3427
3428 /* represent the command as a utility Query */
3432
3433 return result;
3434}
List * expand_function_arguments(List *args, bool include_out_arguments, Oid result_type, HeapTuple func_tuple)
Definition: clauses.c:4179
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:764
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 3241 of file analyze.c.
3242{
3243 Query *result;
3244 Query *query;
3245
3246 /* transform contained query, not allowing SELECT INTO */
3249
3250 /* additional work needed for CREATE MATERIALIZED VIEW */
3252 {
3253 /*
3254 * Prohibit a data-modifying CTE in the query used to create a
3255 * materialized view. It's not sufficiently clear what the user would
3256 * want to happen if the MV is refreshed or incrementally maintained.
3257 */
3258 if (query->hasModifyingCTE)
3260 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3262
3263 /*
3264 * Check whether any temporary database objects are used in the
3265 * creation query. It would be hard to refresh data or incrementally
3266 * maintain it if a source disappeared.
3267 */
3270 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3272
3273 /*
3274 * A materialized view would either need to save parameters for use in
3275 * maintaining/loading the data or prohibit them entirely. The latter
3276 * seems safer and more sane.
3277 */
3280 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3282
3283 /*
3284 * For now, we disallow unlogged materialized views, because it seems
3285 * like a bad idea for them to just go to empty after a crash. (If we
3286 * could mark them as unpopulated, that would be better, but that
3287 * requires catalog changes which crash recovery can't presently
3288 * handle.)
3289 */
3292 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3294
3295 /*
3296 * At runtime, we'll need a copy of the parsed-but-not-rewritten Query
3297 * for purposes of creating the view's ON SELECT rule. We stash that
3298 * in the IntoClause because that's where intorel_startup() can
3299 * conveniently get it from.
3300 */
3302 }
3303
3304 /* represent the command as a utility Query */
3308
3309 return result;
3310}
bool query_contains_extern_params(Query *query)
Definition: parse_param.c:331
bool isQueryUsingTempRelation(Query *query)
Definition: parse_relation.c:3930
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 3096 of file analyze.c.
3097{
3098 Query *result;
3099 Query *query;
3100
3104 (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3105 /* translator: %s is a SQL keyword */
3107 "SCROLL", "NO SCROLL")));
3108
3112 (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3113 /* translator: %s is a SQL keyword */
3115 "ASENSITIVE", "INSENSITIVE")));
3116
3117 /* Transform contained query, not allowing SELECT INTO */
3120
3121 /* Grammar should not have allowed anything but SELECT */
3125
3126 /*
3127 * We also disallow data-modifying WITH in a cursor. (This could be
3128 * allowed, but the semantics of when the updates occur might be
3129 * surprising.)
3130 */
3131 if (query->hasModifyingCTE)
3133 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3135
3136 /* FOR UPDATE and WITH HOLD are not compatible */
3139 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3140 /*------
3141 translator: %s is a SQL row locking clause such as FOR UPDATE */
3146
3147 /* FOR UPDATE and SCROLL are not compatible */
3150 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3151 /*------
3152 translator: %s is a SQL row locking clause such as FOR UPDATE */
3157
3158 /* FOR UPDATE and INSENSITIVE are not compatible */
3161 (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3162 /*------
3163 translator: %s is a SQL row locking clause such as FOR UPDATE */
3168
3169 /* represent the command as a utility Query */
3173
3174 return result;
3175}
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 633 of file analyze.c.
634{
636 ParseNamespaceItem *nsitem;
637 Node *qual;
638
640
641 /* process the WITH clause independently of all else */
643 {
644 qry->hasRecursive = stmt->withClause->recursive;
646 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
647 }
648
649 /* set up range table with just the result rel */
651 stmt->relation->inh,
652 true,
653 ACL_DELETE);
654 nsitem = pstate->p_target_nsitem;
655
656 /* there's no DISTINCT in DELETE */
658
659 /* subqueries in USING cannot access the result relation */
662
663 /*
664 * The USING clause is non-standard SQL syntax, and is equivalent in
665 * functionality to the FROM list that can be specified for UPDATE. The
666 * USING keyword is used rather than FROM because FROM is already a
667 * keyword in the DELETE syntax.
668 */
670
671 /* remaining clauses can reference the result relation normally */
674
677
679 EXPR_KIND_RETURNING);
680
681 /* done building the range table and jointree */
683 qry->rteperminfos = pstate->p_rteperminfos;
685
686 qry->hasSubLinks = pstate->p_hasSubLinks;
687 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
688 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
689 qry->hasAggs = pstate->p_hasAggs;
690
691 assign_query_collations(pstate, qry);
692
693 /* this must be done after collations, for reliable comparison of exprs */
695 parseCheckAggregates(pstate, qry);
696
697 return qry;
698}
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:110
void transformReturningClause(ParseState *pstate, Query *qry, ReturningClause *returningClause, ParseExprKind exprKind)
Definition: analyze.c:2725
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 3189 of file analyze.c.
3190{
3191 Query *result;
3192 bool generic_plan = false;
3193 Oid *paramTypes = NULL;
3194 int numParams = 0;
3195
3196 /*
3197 * If we have no external source of parameter definitions, and the
3198 * GENERIC_PLAN option is specified, then accept variable parameter
3199 * definitions (similarly to PREPARE, for example).
3200 */
3202 {
3203 ListCell *lc;
3204
3206 {
3208
3210 generic_plan = defGetBoolean(opt);
3211 /* don't "break", as we want the last value */
3212 }
3213 if (generic_plan)
3214 setup_parse_variable_parameters(pstate, ¶mTypes, &numParams);
3215 }
3216
3217 /* transform contained query, allowing SELECT INTO */
3219
3220 /* make sure all is well with parameter types */
3221 if (generic_plan)
3223
3224 /* represent the command as a utility Query */
3228
3229 return result;
3230}
static Query * transformOptionalSelectInto(ParseState *pstate, Node *parseTree)
Definition: analyze.c:352
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 1132 of file analyze.c.
1135{
1136 List *result;
1137 ListCell *lc;
1138 ListCell *icols;
1139 ListCell *attnos;
1140
1141 /*
1142 * Check length of expr list. It must not have more expressions than
1143 * there are target columns. We allow fewer, but only if no explicit
1144 * columns list was given (the remaining columns are implicitly
1145 * defaulted). Note we must check this *after* transformation because
1146 * that could expand '*' into multiple items.
1147 */
1150 (errcode(ERRCODE_SYNTAX_ERROR),
1152 parser_errposition(pstate,
1154 list_length(icolumns))))));
1157 {
1158 /*
1159 * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
1160 * where the user accidentally created a RowExpr instead of separate
1161 * columns. Add a suitable hint if that seems to be the problem,
1162 * because the main error message is quite misleading for this case.
1163 * (If there's no stmtcols, you'll get something about data type
1164 * mismatch, which is less misleading so we don't worry about giving a
1165 * hint in that case.)
1166 */
1168 (errcode(ERRCODE_SYNTAX_ERROR),
1170 ((list_length(exprlist) == 1 &&
1172 list_length(icolumns)) ?
1173 errhint("The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?") : 0),
1174 parser_errposition(pstate,
1176 list_length(exprlist))))));
1177 }
1178
1179 /*
1180 * Prepare columns for assignment to target table.
1181 */
1182 result = NIL;
1183 forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
1184 {
1188
1189 expr = transformAssignedExpr(pstate, expr,
1190 EXPR_KIND_INSERT_TARGET,
1191 col->name,
1192 attno,
1193 col->indirection,
1194 col->location);
1195
1196 if (strip_indirection)
1197 {
1198 /*
1199 * We need to remove top-level FieldStores and SubscriptingRefs,
1200 * as well as any CoerceToDomain appearing above one of those ---
1201 * but not a CoerceToDomain that isn't above one of those.
1202 */
1203 while (expr)
1204 {
1205 Expr *subexpr = expr;
1206
1208 {
1209 subexpr = ((CoerceToDomain *) subexpr)->arg;
1210 }
1212 {
1214
1216 }
1218 {
1220
1222 break;
1223
1224 expr = sbsref->refassgnexpr;
1225 }
1226 else
1227 break;
1228 }
1229 }
1230
1231 result = lappend(result, expr);
1232 }
1233
1234 return result;
1235}
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:1419
Definition: primnodes.h:2031
Definition: primnodes.h:1174
Definition: parsenodes.h:526
Definition: primnodes.h:697
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 705 of file analyze.c.
706{
710 bool isGeneralSelect;
711 List *sub_rtable;
712 List *sub_rteperminfos;
713 List *sub_namespace;
714 List *icolumns;
715 List *attrnos;
716 ParseNamespaceItem *nsitem;
717 RTEPermissionInfo *perminfo;
718 ListCell *icols;
719 ListCell *attnos;
720 ListCell *lc;
721 bool isOnConflictUpdate;
722 AclMode targetPerms;
723
724 /* There can't be any outer WITH to worry about */
726
729
730 /* process the WITH clause independently of all else */
732 {
733 qry->hasRecursive = stmt->withClause->recursive;
735 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
736 }
737
738 qry->override = stmt->override;
739
740 isOnConflictUpdate = (stmt->onConflictClause &&
742
743 /*
744 * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL),
745 * VALUES list, or general SELECT input. We special-case VALUES, both for
746 * efficiency and so we can handle DEFAULT specifications.
747 *
748 * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a
749 * VALUES clause. If we have any of those, treat it as a general SELECT;
750 * so it will work, but you can't use DEFAULT items together with those.
751 */
754 selectStmt->limitOffset != NULL ||
755 selectStmt->limitCount != NULL ||
757 selectStmt->withClause != NULL));
758
759 /*
760 * If a non-nil rangetable/namespace was passed in, and we are doing
761 * INSERT/SELECT, arrange to pass the rangetable/rteperminfos/namespace
762 * down to the SELECT. This can only happen if we are inside a CREATE
763 * RULE, and in that case we want the rule's OLD and NEW rtable entries to
764 * appear as part of the SELECT's rtable, not as outer references for it.
765 * (Kluge!) The SELECT's joinlist is not affected however. We must do
766 * this before adding the target table to the INSERT's rtable.
767 */
768 if (isGeneralSelect)
769 {
770 sub_rtable = pstate->p_rtable;
772 sub_rteperminfos = pstate->p_rteperminfos;
774 sub_namespace = pstate->p_namespace;
776 }
777 else
778 {
780 sub_rteperminfos = NIL;
781 sub_namespace = NIL;
782 }
783
784 /*
785 * Must get write lock on INSERT target table before scanning SELECT, else
786 * we will grab the wrong kind of initial lock if the target table is also
787 * mentioned in the SELECT part. Note that the target table is not added
788 * to the joinlist or namespace.
789 */
790 targetPerms = ACL_INSERT;
791 if (isOnConflictUpdate)
792 targetPerms |= ACL_UPDATE;
794 false, false, targetPerms);
795
796 /* Validate stmt->cols list, or build default list if no list given */
799
800 /*
801 * Determine which variant of INSERT we have.
802 */
803 if (selectStmt == NULL)
804 {
805 /*
806 * We have INSERT ... DEFAULT VALUES. We can handle this case by
807 * emitting an empty targetlist --- all columns will be defaulted when
808 * the planner expands the targetlist.
809 */
810 exprList = NIL;
811 }
812 else if (isGeneralSelect)
813 {
814 /*
815 * We make the sub-pstate a child of the outer pstate so that it can
816 * see any Param definitions supplied from above. Since the outer
817 * pstate's rtable and namespace are presently empty, there are no
818 * side-effects of exposing names the sub-SELECT shouldn't be able to
819 * see.
820 */
822 Query *selectQuery;
823
824 /*
825 * Process the source SELECT.
826 *
827 * It is important that this be handled just like a standalone SELECT;
828 * otherwise the behavior of SELECT within INSERT might be different
829 * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had
830 * bugs of just that nature...)
831 *
832 * The sole exception is that we prevent resolving unknown-type
833 * outputs as TEXT. This does not change the semantics since if the
834 * column type matters semantically, it would have been resolved to
835 * something else anyway. Doing this lets us resolve such outputs as
836 * the target column's type, which we handle below.
837 */
838 sub_pstate->p_rtable = sub_rtable;
839 sub_pstate->p_rteperminfos = sub_rteperminfos;
842 sub_pstate->p_namespace = sub_namespace;
844
846
847 free_parsestate(sub_pstate);
848
849 /* The grammar should have produced a SELECT */
853
854 /*
855 * Make the source be a subquery in the INSERT's rangetable, and add
856 * it to the INSERT's joinlist (but not the namespace).
857 */
858 nsitem = addRangeTableEntryForSubquery(pstate,
859 selectQuery,
861 false,
862 false);
864
865 /*----------
866 * Generate an expression list for the INSERT that selects all the
867 * non-resjunk columns from the subquery. (INSERT's tlist must be
868 * separate from the subquery's tlist because we may add columns,
869 * insert datatype coercions, etc.)
870 *
871 * HACK: unknown-type constants and params in the SELECT's targetlist
872 * are copied up as-is rather than being referenced as subquery
873 * outputs. This is to ensure that when we try to coerce them to
874 * the target column's datatype, the right things happen (see
875 * special cases in coerce_type). Otherwise, this fails:
876 * INSERT INTO foo SELECT 'bar', ... FROM baz
877 *----------
878 */
879 exprList = NIL;
881 {
883 Expr *expr;
884
885 if (tle->resjunk)
886 continue;
890 expr = tle->expr;
891 else
892 {
894
896 expr = (Expr *) var;
897 }
898 exprList = lappend(exprList, expr);
899 }
900
901 /* Prepare row for assignment to target table */
902 exprList = transformInsertRow(pstate, exprList,
903 stmt->cols,
904 icolumns, attrnos,
905 false);
906 }
908 {
909 /*
910 * Process INSERT ... VALUES with multiple VALUES sublists. We
911 * generate a VALUES RTE holding the transformed expression lists, and
912 * build up a targetlist containing Vars that reference the VALUES
913 * RTE.
914 */
919 int sublist_length = -1;
920 bool lateral = false;
921
923
925 {
927
928 /*
929 * Do basic expression transformation (same as a ROW() expr, but
930 * allow SetToDefault at top level)
931 */
932 sublist = transformExpressionList(pstate, sublist,
934
935 /*
936 * All the sublists must be the same length, *after*
937 * transformation (which might expand '*' into multiple items).
938 * The VALUES RTE can't handle anything different.
939 */
940 if (sublist_length < 0)
941 {
942 /* Remember post-transformation length of first sublist */
943 sublist_length = list_length(sublist);
944 }
946 {
948 (errcode(ERRCODE_SYNTAX_ERROR),
950 parser_errposition(pstate,
952 }
953
954 /*
955 * Prepare row for assignment to target table. We process any
956 * indirection on the target column specs normally but then strip
957 * off the resulting field/array assignment nodes, since we don't
958 * want the parsed statement to contain copies of those in each
959 * VALUES row. (It's annoying to have to transform the
960 * indirection specs over and over like this, but avoiding it
961 * would take some really messy refactoring of
962 * transformAssignmentIndirection.)
963 */
964 sublist = transformInsertRow(pstate, sublist,
965 stmt->cols,
966 icolumns, attrnos,
967 true);
968
969 /*
970 * We must assign collations now because assign_query_collations
971 * doesn't process rangetable entries. We just assign all the
972 * collations independently in each row, and don't worry about
973 * whether they are consistent vertically. The outer INSERT query
974 * isn't going to care about the collations of the VALUES columns,
975 * so it's not worth the effort to identify a common collation for
976 * each one here. (But note this does have one user-visible
977 * consequence: INSERT ... VALUES won't complain about conflicting
978 * explicit COLLATEs in a column, whereas the same VALUES
979 * construct in another context would complain.)
980 */
981 assign_list_collations(pstate, sublist);
982
983 exprsLists = lappend(exprsLists, sublist);
984 }
985
986 /*
987 * Construct column type/typmod/collation lists for the VALUES RTE.
988 * Every expression in each column has been coerced to the type/typmod
989 * of the corresponding target column or subfield, so it's sufficient
990 * to look at the exprType/exprTypmod of the first row. We don't care
991 * about the collation labeling, so just fill in InvalidOid for that.
992 */
994 {
996
1000 }
1001
1002 /*
1003 * Ordinarily there can't be any current-level Vars in the expression
1004 * lists, because the namespace was empty ... but if we're inside
1005 * CREATE RULE, then NEW/OLD references might appear. In that case we
1006 * have to mark the VALUES RTE as LATERAL.
1007 */
1010 lateral = true;
1011
1012 /*
1013 * Generate the VALUES RTE
1014 */
1015 nsitem = addRangeTableEntryForValues(pstate, exprsLists,
1016 coltypes, coltypmods, colcollations,
1017 NULL, lateral, true);
1019
1020 /*
1021 * Generate list of Vars referencing the RTE
1022 */
1023 exprList = expandNSItemVars(pstate, nsitem, 0, -1, NULL);
1024
1025 /*
1026 * Re-apply any indirection on the target column specs to the Vars
1027 */
1028 exprList = transformInsertRow(pstate, exprList,
1029 stmt->cols,
1030 icolumns, attrnos,
1031 false);
1032 }
1033 else
1034 {
1035 /*
1036 * Process INSERT ... VALUES with a single VALUES sublist. We treat
1037 * this case separately for efficiency. The sublist is just computed
1038 * directly as the Query's targetlist, with no VALUES RTE. So it
1039 * works just like a SELECT without any FROM.
1040 */
1042
1045
1046 /*
1047 * Do basic expression transformation (same as a ROW() expr, but allow
1048 * SetToDefault at top level)
1049 */
1050 exprList = transformExpressionList(pstate,
1052 EXPR_KIND_VALUES_SINGLE,
1053 true);
1054
1055 /* Prepare row for assignment to target table */
1056 exprList = transformInsertRow(pstate, exprList,
1057 stmt->cols,
1058 icolumns, attrnos,
1059 false);
1060 }
1061
1062 /*
1063 * Generate query's target list using the computed list of expressions.
1064 * Also, mark all the target columns as needing insert permissions.
1065 */
1069 forthree(lc, exprList, icols, icolumns, attnos, attrnos)
1070 {
1074 TargetEntry *tle;
1075
1076 tle = makeTargetEntry(expr,
1077 attr_num,
1078 col->name,
1079 false);
1081
1082 perminfo->insertedCols = bms_add_member(perminfo->insertedCols,
1083 attr_num - FirstLowInvalidHeapAttributeNumber);
1084 }
1085
1086 /*
1087 * If we have any clauses yet to process, set the query namespace to
1088 * contain only the target relation, removing any entries added in a
1089 * sub-SELECT or VALUES list.
1090 */
1092 {
1095 false, true, true);
1096 }
1097
1098 /* Process ON CONFLICT, if any. */
1101 stmt->onConflictClause);
1102
1103 /* Process RETURNING, if any. */
1106 EXPR_KIND_RETURNING);
1107
1108 /* done building the range table and jointree */
1110 qry->rteperminfos = pstate->p_rteperminfos;
1112
1113 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
1114 qry->hasSubLinks = pstate->p_hasSubLinks;
1115
1116 assign_query_collations(pstate, qry);
1117
1118 return qry;
1119}
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:3227
ParseNamespaceItem * addRangeTableEntryForSubquery(ParseState *pstate, Query *subquery, Alias *alias, bool lateral, bool inFromCl)
Definition: parse_relation.c:1655
ParseNamespaceItem * addRangeTableEntryForValues(ParseState *pstate, List *exprs, List *coltypes, List *coltypmods, List *colcollations, Alias *alias, bool lateral, bool inFromCl)
Definition: parse_relation.c:2151
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:1242
List * transformInsertRow(ParseState *pstate, List *exprlist, List *stmtcols, List *icolumns, List *attrnos, bool strip_indirection)
Definition: analyze.c:1132
Definition: primnodes.h:324
Definition: primnodes.h:391
Definition: parsenodes.h:1300
#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 3530 of file analyze.c.
3532{
3534 ListCell *l;
3535 ListCell *rt;
3537 LockingClause *allrels;
3538
3540
3541 /* make a clause we can pass down to subqueries to select all rels */
3546
3548 {
3549 /*
3550 * Lock all regular tables used in query and its subqueries. We
3551 * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
3552 * in rules. This is a bit of an abuse of a mostly-obsolete flag, but
3553 * it's convenient. We can't rely on the namespace mechanism that has
3554 * largely replaced inFromCl, since for example we need to lock
3555 * base-relation RTEs even if they are masked by upper joins.
3556 */
3557 i = 0;
3559 {
3561
3562 ++i;
3563 if (!rte->inFromCl)
3564 continue;
3566 {
3568 {
3569 RTEPermissionInfo *perminfo;
3570
3572 lc->strength,
3573 lc->waitPolicy,
3574 pushedDown);
3575 perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
3577 }
3578 break;
3581 pushedDown);
3582
3583 /*
3584 * FOR UPDATE/SHARE of subquery is propagated to all of
3585 * subquery's rels, too. We could do this later (based on
3586 * the marking of the subquery RTE) but it is convenient
3587 * to have local knowledge in each query level about which
3588 * rels need to be opened with RowShareLock.
3589 */
3591 allrels, true);
3592 break;
3593 default:
3594 /* ignore JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */
3595 break;
3596 }
3597 }
3598 }
3599 else
3600 {
3601 /*
3602 * Lock just the named tables. As above, we allow locking any base
3603 * relation regardless of alias-visibility rules, so we need to
3604 * examine inFromCl to exclude OLD/NEW.
3605 */
3606 foreach(l, lockedRels)
3607 {
3609
3610 /* For simplicity we insist on unqualified alias names here */
3613 (errcode(ERRCODE_SYNTAX_ERROR),
3614 /*------
3615 translator: %s is a SQL row locking clause such as FOR UPDATE */
3619
3620 i = 0;
3622 {
3624 char *rtename = rte->eref->aliasname;
3625
3626 ++i;
3627 if (!rte->inFromCl)
3628 continue;
3629
3630 /*
3631 * A join RTE without an alias is not visible as a relation
3632 * name and needs to be skipped (otherwise it might hide a
3633 * base relation with the same name), except if it has a USING
3634 * alias, which *is* visible.
3635 *
3636 * Subquery and values RTEs without aliases are never visible
3637 * as relation names and must always be skipped.
3638 */
3639 if (rte->alias == NULL)
3640 {
3642 {
3643 if (rte->join_using_alias == NULL)
3644 continue;
3645 rtename = rte->join_using_alias->aliasname;
3646 }
3649 continue;
3650 }
3651
3653 {
3655 {
3657 {
3658 RTEPermissionInfo *perminfo;
3659
3661 lc->strength,
3662 lc->waitPolicy,
3663 pushedDown);
3664 perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
3666 }
3667 break;
3670 lc->waitPolicy, pushedDown);
3671 /* see comment above */
3673 allrels, true);
3674 break;
3677 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3678 /*------
3679 translator: %s is a SQL row locking clause such as FOR UPDATE */
3683 break;
3686 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3687 /*------
3688 translator: %s is a SQL row locking clause such as FOR UPDATE */
3692 break;
3695 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3696 /*------
3697 translator: %s is a SQL row locking clause such as FOR UPDATE */
3701 break;
3704 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3705 /*------
3706 translator: %s is a SQL row locking clause such as FOR UPDATE */
3710 break;
3713 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3714 /*------
3715 translator: %s is a SQL row locking clause such as FOR UPDATE */
3719 break;
3722 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3723 /*------
3724 translator: %s is a SQL row locking clause such as FOR UPDATE */
3728 break;
3729
3730 /* Shouldn't be possible to see RTE_RESULT here */
3731
3732 default:
3735 break;
3736 }
3737 break; /* out of foreach loop */
3738 }
3739 }
3740 if (rt == NULL)
3743 /*------
3744 translator: %s is a SQL row locking clause such as FOR UPDATE */
3746 thisrel->relname,
3749 }
3750 }
3751}
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
Definition: parse_relation.c:4009
static void transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc, bool pushedDown)
Definition: analyze.c:3530
void CheckSelectLocking(Query *qry, LockClauseStrength strength)
Definition: analyze.c:3466
void applyLockingClause(Query *qry, Index rtindex, LockClauseStrength strength, LockWaitPolicy waitPolicy, bool pushedDown)
Definition: analyze.c:3757
Definition: parsenodes.h:843
Definition: primnodes.h:73
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 1242 of file analyze.c.
1244{
1245 ParseNamespaceItem *exclNSItem = NULL;
1246 List *arbiterElems;
1247 Node *arbiterWhere;
1248 Oid arbiterConstraint;
1250 Node *onConflictWhere = NULL;
1251 int exclRelIndex = 0;
1253 OnConflictExpr *result;
1254
1255 /*
1256 * If this is ON CONFLICT ... UPDATE, first create the range table entry
1257 * for the EXCLUDED pseudo relation, so that that will be present while
1258 * processing arbiter expressions. (You can't actually reference it from
1259 * there, but this provides a useful error message if you try.)
1260 */
1262 {
1264 RangeTblEntry *exclRte;
1265
1266 exclNSItem = addRangeTableEntryForRelation(pstate,
1267 targetrel,
1268 RowExclusiveLock,
1270 false, false);
1271 exclRte = exclNSItem->p_rte;
1272 exclRelIndex = exclNSItem->p_rtindex;
1273
1274 /*
1275 * relkind is set to composite to signal that we're not dealing with
1276 * an actual relation, and no permission checks are required on it.
1277 * (We'll check the actual target relation, instead.)
1278 */
1279 exclRte->relkind = RELKIND_COMPOSITE_TYPE;
1280
1281 /* Create EXCLUDED rel's targetlist for use by EXPLAIN */
1282 exclRelTlist = BuildOnConflictExcludedTargetlist(targetrel,
1283 exclRelIndex);
1284 }
1285
1286 /* Process the arbiter clause, ON CONFLICT ON (...) */
1287 transformOnConflictArbiter(pstate, onConflictClause, &arbiterElems,
1288 &arbiterWhere, &arbiterConstraint);
1289
1290 /* Process DO UPDATE */
1292 {
1293 /*
1294 * Expressions in the UPDATE targetlist need to be handled like UPDATE
1295 * not INSERT. We don't need to save/restore this because all INSERT
1296 * expressions have been parsed already.
1297 */
1299
1300 /*
1301 * Add the EXCLUDED pseudo relation to the query namespace, making it
1302 * available in the UPDATE subexpressions.
1303 */
1305
1306 /*
1307 * Now transform the UPDATE subexpressions.
1308 */
1309 onConflictSet =
1311
1312 onConflictWhere = transformWhereClause(pstate,
1313 onConflictClause->whereClause,
1315
1316 /*
1317 * Remove the EXCLUDED pseudo relation from the query namespace, since
1318 * it's not supposed to be available in RETURNING. (Maybe someday we
1319 * could allow that, and drop this step.)
1320 */
1323 }
1324
1325 /* Finally, build ON CONFLICT DO [NOTHING | UPDATE] expression */
1327
1329 result->arbiterElems = arbiterElems;
1330 result->arbiterWhere = arbiterWhere;
1331 result->constraint = arbiterConstraint;
1332 result->onConflictSet = onConflictSet;
1333 result->onConflictWhere = onConflictWhere;
1334 result->exclRelIndex = exclRelIndex;
1335 result->exclRelTlist = exclRelTlist;
1336
1337 return result;
1338}
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:1584
List * transformUpdateTargetList(ParseState *pstate, List *origTlist)
Definition: analyze.c:2610
List * BuildOnConflictExcludedTargetlist(Relation targetrel, Index exclRelIndex)
Definition: analyze.c:1349
Definition: primnodes.h:2351
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 352 of file analyze.c.
353{
355 {
357
358 /* If it's a set-operation tree, drill down to leftmost SelectStmt */
362
364 {
366
367 ctas->query = parseTree;
371
372 /*
373 * Remove the intoClause from the SelectStmt. This makes it safe
374 * for transformSelectStmt to complain if it finds intoClause set
375 * (implying that the INTO appeared in a disallowed place).
376 */
377 stmt->intoClause = NULL;
378
379 parseTree = (Node *) ctas;
380 }
381 }
382
384}
Definition: parsenodes.h:3985
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 2847 of file analyze.c.
2848{
2854 Node *target;
2855 Oid targettype;
2856 int32 targettypmod;
2857 Oid targetcollation;
2858 List *tlist;
2859 TargetEntry *tle;
2860 Oid type_id;
2861 Node *qual;
2862 ListCell *l;
2863
2864 /*
2865 * First, construct a ColumnRef for the target variable. If the target
2866 * has more than one dotted name, we have to pull the extra names out of
2867 * the indirection list.
2868 */
2871 if (nnames > 1)
2872 {
2873 /* avoid munging the raw parsetree */
2874 indirection = list_copy(indirection);
2876 {
2878
2882 indirection = list_delete_first(indirection);
2883 }
2884 }
2885
2886 /*
2887 * Transform the target reference. Typically we will get back a Param
2888 * node, but there's no reason to be too picky about its type.
2889 */
2891 EXPR_KIND_UPDATE_TARGET);
2892 targettype = exprType(target);
2893 targettypmod = exprTypmod(target);
2894 targetcollation = exprCollation(target);
2895
2896 /*
2897 * The rest mostly matches transformSelectStmt, except that we needn't
2898 * consider WITH or INTO, and we build a targetlist our own way.
2899 */
2902
2903 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
2905
2906 /* make WINDOW info available for window functions, too */
2908
2909 /* process the FROM clause */
2911
2912 /* initially transform the targetlist as if in SELECT */
2914 EXPR_KIND_SELECT_TARGET);
2915
2916 /* we should have exactly one targetlist item */
2919 (errcode(ERRCODE_SYNTAX_ERROR),
2921 "assignment source returned %d columns",
2922 list_length(tlist),
2923 list_length(tlist))));
2924
2926
2927 /*
2928 * This next bit is similar to transformAssignedExpr; the key difference
2929 * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT.
2930 */
2932
2934
2935 if (indirection)
2936 {
2938 transformAssignmentIndirection(pstate,
2939 target,
2940 stmt->name,
2941 false,
2942 targettype,
2943 targettypmod,
2944 targetcollation,
2945 indirection,
2946 list_head(indirection),
2948 COERCION_PLPGSQL,
2949 exprLocation(target));
2950 }
2951 else if (targettype != type_id &&
2952 (targettype == RECORDOID || ISCOMPLEX(targettype)) &&
2953 (type_id == RECORDOID || ISCOMPLEX(type_id)))
2954 {
2955 /*
2956 * Hack: do not let coerce_to_target_type() deal with inconsistent
2957 * composite types. Just pass the expression result through as-is,
2958 * and let the PL/pgSQL executor do the conversion its way. This is
2959 * rather bogus, but it's needed for backwards compatibility.
2960 */
2961 }
2962 else
2963 {
2964 /*
2965 * For normal non-qualified target column, do type checking and
2966 * coercion.
2967 */
2969
2971 coerce_to_target_type(pstate,
2972 orig_expr, type_id,
2973 targettype, targettypmod,
2974 COERCION_PLPGSQL,
2975 COERCE_IMPLICIT_CAST,
2976 -1);
2977 /* With COERCION_PLPGSQL, this error is probably unreachable */
2980 (errcode(ERRCODE_DATATYPE_MISMATCH),
2982 " but expression is of type %s",
2983 stmt->name,
2984 format_type_be(targettype),
2985 format_type_be(type_id)),
2988 }
2989
2991
2993
2994 /* transform WHERE */
2997
2998 /* initial processing of HAVING clause is much like WHERE clause */
3001
3002 /*
3003 * Transform sorting/grouping stuff. Do ORDER BY first because both
3004 * transformGroupClause and transformDistinctClause need the results. Note
3005 * that these functions can also change the targetList, so it's passed to
3006 * them by reference.
3007 */
3009 sstmt->sortClause,
3010 &qry->targetList,
3011 EXPR_KIND_ORDER_BY,
3012 false /* allow SQL92 rules */ );
3013
3015 sstmt->groupClause,
3016 &qry->groupingSets,
3017 &qry->targetList,
3018 qry->sortClause,
3019 EXPR_KIND_GROUP_BY,
3020 false /* allow SQL92 rules */ );
3021
3023 {
3025 qry->hasDistinctOn = false;
3026 }
3028 {
3029 /* We had SELECT DISTINCT */
3031 &qry->targetList,
3032 qry->sortClause,
3033 false);
3034 qry->hasDistinctOn = false;
3035 }
3036 else
3037 {
3038 /* We had SELECT DISTINCT ON */
3040 sstmt->distinctClause,
3041 &qry->targetList,
3042 qry->sortClause);
3043 qry->hasDistinctOn = true;
3044 }
3045
3046 /* transform LIMIT */
3049 sstmt->limitOption);
3052 sstmt->limitOption);
3054
3055 /* transform window clauses after we have seen all window functions */
3057 pstate->p_windowdefs,
3058 &qry->targetList);
3059
3061 qry->rteperminfos = pstate->p_rteperminfos;
3063
3064 qry->hasSubLinks = pstate->p_hasSubLinks;
3065 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
3066 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
3067 qry->hasAggs = pstate->p_hasAggs;
3068
3070 {
3071 transformLockingClause(pstate, qry,
3073 }
3074
3075 assign_query_collations(pstate, qry);
3076
3077 /* this must be done after collations, for reliable comparison of exprs */
3079 parseCheckAggregates(pstate, qry);
3080
3081 return qry;
3082}
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1181
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 2725 of file analyze.c.
2728{
2730 int save_next_resno;
2731
2732 if (returningClause == NULL)
2733 return; /* nothing to do */
2734
2735 /*
2736 * Scan RETURNING WITH(...) options for OLD/NEW alias names. Complain if
2737 * there is any conflict with existing relations.
2738 */
2740 {
2742 {
2744 if (qry->returningOldAlias != NULL)
2746 errcode(ERRCODE_SYNTAX_ERROR),
2747 /* translator: %s is OLD or NEW */
2750 qry->returningOldAlias = option->value;
2751 break;
2752
2754 if (qry->returningNewAlias != NULL)
2756 errcode(ERRCODE_SYNTAX_ERROR),
2757 /* translator: %s is OLD or NEW */
2760 qry->returningNewAlias = option->value;
2761 break;
2762
2763 default:
2765 }
2766
2769 errcode(ERRCODE_DUPLICATE_ALIAS),
2771 option->value),
2773
2777 }
2778
2779 /*
2780 * If OLD/NEW alias names weren't explicitly specified, use "old"/"new"
2781 * unless masked by existing relations.
2782 */
2783 if (qry->returningOldAlias == NULL &&
2785 {
2786 qry->returningOldAlias = "old";
2788 }
2789 if (qry->returningNewAlias == NULL &&
2791 {
2792 qry->returningNewAlias = "new";
2794 }
2795
2796 /*
2797 * We need to assign resnos starting at one in the RETURNING list. Save
2798 * and restore the main tlist's value of p_next_resno, just in case
2799 * someone looks at it later (probably won't happen).
2800 */
2801 save_next_resno = pstate->p_next_resno;
2802 pstate->p_next_resno = 1;
2803
2804 /* transform RETURNING expressions identically to a SELECT targetlist */
2806 returningClause->exprs,
2807 exprKind);
2808
2809 /*
2810 * Complain if the nonempty tlist expanded to nothing (which is possible
2811 * if it contains only a star-expansion of a zero-column table). If we
2812 * allow this, the parsed Query will look like it didn't have RETURNING,
2813 * with results that would probably surprise the user.
2814 */
2817 (errcode(ERRCODE_SYNTAX_ERROR),
2819 parser_errposition(pstate,
2821
2822 /* mark column origins */
2824
2825 /* resolve any still-unresolved output columns as being type text */
2828
2829 /* restore state */
2831 pstate->p_next_resno = save_next_resno;
2832}
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:2685
Definition: parsenodes.h:1760
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 2513 of file analyze.c.
2514{
2516
2518 qry->isReturn = true;
2519
2520 qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET),
2521 1, NULL, false));
2522
2526 qry->rteperminfos = pstate->p_rteperminfos;
2528 qry->hasSubLinks = pstate->p_hasSubLinks;
2529 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
2530 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2531 qry->hasAggs = pstate->p_hasAggs;
2532
2533 assign_query_collations(pstate, qry);
2534
2535 return qry;
2536}
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 1461 of file analyze.c.
1462{
1464 Node *qual;
1465 ListCell *l;
1466
1468
1469 /* process the WITH clause independently of all else */
1471 {
1472 qry->hasRecursive = stmt->withClause->recursive;
1474 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1475 }
1476
1477 /* Complain if we get called from someplace where INTO is not allowed */
1480 (errcode(ERRCODE_SYNTAX_ERROR),
1482 parser_errposition(pstate,
1484
1485 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
1487
1488 /* make WINDOW info available for window functions, too */
1490
1491 /* process the FROM clause */
1493
1494 /* transform targetlist */
1496 EXPR_KIND_SELECT_TARGET);
1497
1498 /* mark column origins */
1500
1501 /* transform WHERE */
1504
1505 /* initial processing of HAVING clause is much like WHERE clause */
1508
1509 /*
1510 * Transform sorting/grouping stuff. Do ORDER BY first because both
1511 * transformGroupClause and transformDistinctClause need the results. Note
1512 * that these functions can also change the targetList, so it's passed to
1513 * them by reference.
1514 */
1516 stmt->sortClause,
1517 &qry->targetList,
1518 EXPR_KIND_ORDER_BY,
1519 false /* allow SQL92 rules */ );
1520
1522 stmt->groupClause,
1523 &qry->groupingSets,
1524 &qry->targetList,
1525 qry->sortClause,
1526 EXPR_KIND_GROUP_BY,
1527 false /* allow SQL92 rules */ );
1529
1531 {
1533 qry->hasDistinctOn = false;
1534 }
1536 {
1537 /* We had SELECT DISTINCT */
1539 &qry->targetList,
1540 qry->sortClause,
1541 false);
1542 qry->hasDistinctOn = false;
1543 }
1544 else
1545 {
1546 /* We had SELECT DISTINCT ON */
1548 stmt->distinctClause,
1549 &qry->targetList,
1550 qry->sortClause);
1551 qry->hasDistinctOn = true;
1552 }
1553
1554 /* transform LIMIT */
1557 stmt->limitOption);
1560 stmt->limitOption);
1562
1563 /* transform window clauses after we have seen all window functions */
1565 pstate->p_windowdefs,
1566 &qry->targetList);
1567
1568 /* resolve any still-unresolved output columns as being type text */
1571
1573 qry->rteperminfos = pstate->p_rteperminfos;
1575
1576 qry->hasSubLinks = pstate->p_hasSubLinks;
1577 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
1578 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
1579 qry->hasAggs = pstate->p_hasAggs;
1580
1582 {
1583 transformLockingClause(pstate, qry,
1585 }
1586
1587 assign_query_collations(pstate, qry);
1588
1589 /* this must be done after collations, for reliable comparison of exprs */
1591 parseCheckAggregates(pstate, qry);
1592
1593 return qry;
1594}
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 1823 of file analyze.c.
1824{
1826 SelectStmt *leftmostSelect;
1827 int leftmostRTI;
1828 Query *leftmostQuery;
1829 SetOperationStmt *sostmt;
1830 List *sortClause;
1831 Node *limitOffset;
1832 Node *limitCount;
1833 List *lockingClause;
1834 WithClause *withClause;
1835 Node *node;
1836 ListCell *left_tlist,
1837 *lct,
1838 *lcm,
1839 *lcc,
1840 *l;
1841 List *targetvars,
1842 *targetnames,
1843 *sv_namespace;
1844 int sv_rtable_length;
1845 ParseNamespaceItem *jnsitem;
1846 ParseNamespaceColumn *sortnscolumns;
1847 int sortcolindex;
1848 int tllen;
1849
1851
1852 /*
1853 * Find leftmost leaf SelectStmt. We currently only need to do this in
1854 * order to deliver a suitable error message if there's an INTO clause
1855 * there, implying the set-op tree is in a context that doesn't allow
1856 * INTO. (transformSetOperationTree would throw error anyway, but it
1857 * seems worth the trouble to throw a different error for non-leftmost
1858 * INTO, so we produce that error in transformSetOperationTree.)
1859 */
1860 leftmostSelect = stmt->larg;
1862 leftmostSelect = leftmostSelect->larg;
1864 leftmostSelect->larg == NULL);
1867 (errcode(ERRCODE_SYNTAX_ERROR),
1869 parser_errposition(pstate,
1871
1872 /*
1873 * We need to extract ORDER BY and other top-level clauses here and not
1874 * let transformSetOperationTree() see them --- else it'll just recurse
1875 * right back here!
1876 */
1877 sortClause = stmt->sortClause;
1878 limitOffset = stmt->limitOffset;
1879 limitCount = stmt->limitCount;
1880 lockingClause = stmt->lockingClause;
1881 withClause = stmt->withClause;
1882
1884 stmt->limitOffset = NULL;
1885 stmt->limitCount = NULL;
1887 stmt->withClause = NULL;
1888
1889 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
1890 if (lockingClause)
1892 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1893 /*------
1894 translator: %s is a SQL row locking clause such as FOR UPDATE */
1897 linitial(lockingClause))->strength))));
1898
1899 /* Process the WITH clause independently of all else */
1900 if (withClause)
1901 {
1902 qry->hasRecursive = withClause->recursive;
1904 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1905 }
1906
1907 /*
1908 * Recursively transform the components of the tree.
1909 */
1912 Assert(sostmt);
1914
1915 /*
1916 * Re-find leftmost SELECT (now it's a sub-query in rangetable)
1917 */
1918 node = sostmt->larg;
1920 node = ((SetOperationStmt *) node)->larg;
1922 leftmostRTI = ((RangeTblRef *) node)->rtindex;
1924 Assert(leftmostQuery != NULL);
1925
1926 /*
1927 * Generate dummy targetlist for outer query using column names of
1928 * leftmost select and common datatypes/collations of topmost set
1929 * operation. Also make lists of the dummy vars and their names for use
1930 * in parsing ORDER BY.
1931 *
1932 * Note: we use leftmostRTI as the varno of the dummy variables. It
1933 * shouldn't matter too much which RT index they have, as long as they
1934 * have one that corresponds to a real RT entry; else funny things may
1935 * happen when the tree is mashed by rule rewriting.
1936 */
1938 targetvars = NIL;
1939 targetnames = NIL;
1940 sortnscolumns = (ParseNamespaceColumn *)
1942 sortcolindex = 0;
1943
1944 forfour(lct, sostmt->colTypes,
1945 lcm, sostmt->colTypmods,
1946 lcc, sostmt->colCollations,
1947 left_tlist, leftmostQuery->targetList)
1948 {
1953 char *colName;
1954 TargetEntry *tle;
1955 Var *var;
1956
1957 Assert(!lefttle->resjunk);
1958 colName = pstrdup(lefttle->resname);
1959 var = makeVar(leftmostRTI,
1960 lefttle->resno,
1961 colType,
1962 colTypmod,
1963 colCollation,
1964 0);
1968 colName,
1969 false);
1971 targetvars = lappend(targetvars, var);
1973 sortnscolumns[sortcolindex].p_varno = leftmostRTI;
1975 sortnscolumns[sortcolindex].p_vartype = colType;
1976 sortnscolumns[sortcolindex].p_vartypmod = colTypmod;
1977 sortnscolumns[sortcolindex].p_varcollid = colCollation;
1978 sortnscolumns[sortcolindex].p_varnosyn = leftmostRTI;
1980 sortcolindex++;
1981 }
1982
1983 /*
1984 * As a first step towards supporting sort clauses that are expressions
1985 * using the output columns, generate a namespace entry that makes the
1986 * output columns visible. A Join RTE node is handy for this, since we
1987 * can easily control the Vars generated upon matches.
1988 *
1989 * Note: we don't yet do anything useful with such cases, but at least
1990 * "ORDER BY upper(foo)" will draw the right error message rather than
1991 * "foo not found".
1992 */
1994
1995 jnsitem = addRangeTableEntryForJoin(pstate,
1996 targetnames,
1997 sortnscolumns,
1998 JOIN_INNER,
1999 0,
2000 targetvars,
2001 NIL,
2002 NIL,
2003 NULL,
2004 NULL,
2005 false);
2006
2007 sv_namespace = pstate->p_namespace;
2009
2010 /* add jnsitem to column namespace only */
2012
2013 /*
2014 * For now, we don't support resjunk sort clauses on the output of a
2015 * setOperation tree --- you can only use the SQL92-spec options of
2016 * selecting an output column by name or number. Enforce by checking that
2017 * transformSortClause doesn't add any items to tlist. Note, if changing
2018 * this, add_setop_child_rel_equivalences() will need to be updated.
2019 */
2021
2023 sortClause,
2024 &qry->targetList,
2025 EXPR_KIND_ORDER_BY,
2026 false /* allow SQL92 rules */ );
2027
2028 /* restore namespace, remove join RTE from rtable */
2029 pstate->p_namespace = sv_namespace;
2031
2034 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2038 parser_errposition(pstate,
2040
2043 stmt->limitOption);
2046 stmt->limitOption);
2048
2050 qry->rteperminfos = pstate->p_rteperminfos;
2052
2053 qry->hasSubLinks = pstate->p_hasSubLinks;
2054 qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
2055 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2056 qry->hasAggs = pstate->p_hasAggs;
2057
2058 foreach(l, lockingClause)
2059 {
2060 transformLockingClause(pstate, qry,
2062 }
2063
2064 assign_query_collations(pstate, qry);
2065
2066 /* this must be done after collations, for reliable comparison of exprs */
2068 parseCheckAggregates(pstate, qry);
2069
2070 return qry;
2071}
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:2233
static Node * transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, bool isTopLevel, List **targetlist)
Definition: analyze.c:2128
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
Definition: pg_list.h:575
Definition: parsenodes.h:1607
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 2128 of file analyze.c.
2130{
2131 bool isLeaf;
2132
2134
2135 /* Guard against stack overflow due to overly complex set-expressions */
2136 check_stack_depth();
2137
2138 /*
2139 * Validity-check both leaf and internal SELECTs for disallowed ops.
2140 */
2143 (errcode(ERRCODE_SYNTAX_ERROR),
2145 parser_errposition(pstate,
2147
2148 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
2151 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2152 /*------
2153 translator: %s is a SQL row locking clause such as FOR UPDATE */
2157
2158 /*
2159 * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE,
2160 * or WITH clauses attached, we need to treat it like a leaf node to
2161 * generate an independent sub-Query tree. Otherwise, it can be
2162 * represented by a SetOperationStmt node underneath the parent Query.
2163 */
2165 {
2167 isLeaf = true;
2168 }
2169 else
2170 {
2174 isLeaf = true;
2175 else
2176 isLeaf = false;
2177 }
2178
2179 if (isLeaf)
2180 {
2181 /* Process leaf SELECT */
2182 Query *selectQuery;
2183 char selectName[32];
2184 ParseNamespaceItem *nsitem;
2185 RangeTblRef *rtr;
2186 ListCell *tl;
2187
2188 /*
2189 * Transform SelectStmt into a Query.
2190 *
2191 * This works the same as SELECT transformation normally would, except
2192 * that we prevent resolving unknown-type outputs as TEXT. This does
2193 * not change the subquery's semantics since if the column type
2194 * matters semantically, it would have been resolved to something else
2195 * anyway. Doing this lets us resolve such outputs using
2196 * select_common_type(), below.
2197 *
2198 * Note: previously transformed sub-queries don't affect the parsing
2199 * of this sub-query, because they are not in the toplevel pstate's
2200 * namespace list.
2201 */
2203 NULL, false, false);
2204
2205 /*
2206 * Check for bogus references to Vars on the current query level (but
2207 * upper-level references are okay). Normally this can't happen
2208 * because the namespace will be empty, but it could happen if we are
2209 * inside a rule.
2210 */
2212 {
2215 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2216 errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
2217 parser_errposition(pstate,
2219 }
2220
2221 /*
2222 * Extract a list of the non-junk TLEs for upper-level processing.
2223 */
2224 if (targetlist)
2225 {
2226 *targetlist = NIL;
2227 foreach(tl, selectQuery->targetList)
2228 {
2230
2231 if (!tle->resjunk)
2232 *targetlist = lappend(*targetlist, tle);
2233 }
2234 }
2235
2236 /*
2237 * Make the leaf query be a subquery in the top-level rangetable.
2238 */
2241 nsitem = addRangeTableEntryForSubquery(pstate,
2242 selectQuery,
2244 false,
2245 false);
2246
2247 /*
2248 * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
2249 */
2253 }
2254 else
2255 {
2256 /* Process an internal node (set operation node) */
2258 List *ltargetlist;
2259 List *rtargetlist;
2260 ListCell *ltl;
2261 ListCell *rtl;
2262 const char *context;
2264 pstate->p_parent_cte->cterecursive);
2265
2268 "EXCEPT"));
2269
2272
2273 /*
2274 * Recursively transform the left child node.
2275 */
2277 false,
2278 <argetlist);
2279
2280 /*
2281 * If we are processing a recursive union query, now is the time to
2282 * examine the non-recursive term's output columns and mark the
2283 * containing CTE as having those result columns. We should do this
2284 * only at the topmost setop of the CTE, of course.
2285 */
2286 if (isTopLevel && recursive)
2288
2289 /*
2290 * Recursively transform the right child node.
2291 */
2293 false,
2294 &rtargetlist);
2295
2296 /*
2297 * Verify that the two children have the same number of non-junk
2298 * columns, and determine the types of the merged output columns.
2299 */
2302 (errcode(ERRCODE_SYNTAX_ERROR),
2304 context),
2305 parser_errposition(pstate,
2307
2308 if (targetlist)
2309 *targetlist = NIL;
2310 op->colTypes = NIL;
2311 op->colTypmods = NIL;
2312 op->colCollations = NIL;
2313 op->groupClauses = NIL;
2314 forboth(ltl, ltargetlist, rtl, rtargetlist)
2315 {
2322 Node *bestexpr;
2323 int bestlocation;
2324 Oid rescoltype;
2325 int32 rescoltypmod;
2326 Oid rescolcoll;
2327
2328 /* select common type, same as CASE et al */
2329 rescoltype = select_common_type(pstate,
2330 list_make2(lcolnode, rcolnode),
2331 context,
2332 &bestexpr);
2333 bestlocation = exprLocation(bestexpr);
2334
2335 /*
2336 * Verify the coercions are actually possible. If not, we'd fail
2337 * later anyway, but we want to fail now while we have sufficient
2338 * context to produce an error cursor position.
2339 *
2340 * For all non-UNKNOWN-type cases, we verify coercibility but we
2341 * don't modify the child's expression, for fear of changing the
2342 * child query's semantics.
2343 *
2344 * If a child expression is an UNKNOWN-type Const or Param, we
2345 * want to replace it with the coerced expression. This can only
2346 * happen when the child is a leaf set-op node. It's safe to
2347 * replace the expression because if the child query's semantics
2348 * depended on the type of this output column, it'd have already
2349 * coerced the UNKNOWN to something else. We want to do this
2350 * because (a) we want to verify that a Const is valid for the
2351 * target type, or resolve the actual type of an UNKNOWN Param,
2352 * and (b) we want to avoid unnecessary discrepancies between the
2353 * output type of the child query and the resolved target type.
2354 * Such a discrepancy would disable optimization in the planner.
2355 *
2356 * If it's some other UNKNOWN-type node, eg a Var, we do nothing
2357 * (knowing that coerce_to_common_type would fail). The planner
2358 * is sometimes able to fold an UNKNOWN Var to a constant before
2359 * it has to coerce the type, so failing now would just break
2360 * cases that might work.
2361 */
2362 if (lcoltype != UNKNOWNOID)
2363 lcolnode = coerce_to_common_type(pstate, lcolnode,
2364 rescoltype, context);
2367 {
2368 lcolnode = coerce_to_common_type(pstate, lcolnode,
2369 rescoltype, context);
2371 }
2372
2373 if (rcoltype != UNKNOWNOID)
2374 rcolnode = coerce_to_common_type(pstate, rcolnode,
2375 rescoltype, context);
2378 {
2379 rcolnode = coerce_to_common_type(pstate, rcolnode,
2380 rescoltype, context);
2382 }
2383
2384 rescoltypmod = select_common_typmod(pstate,
2385 list_make2(lcolnode, rcolnode),
2386 rescoltype);
2387
2388 /*
2389 * Select common collation. A common collation is required for
2390 * all set operators except UNION ALL; see SQL:2008 7.13 <query
2391 * expression> Syntax Rule 15c. (If we fail to identify a common
2392 * collation for a UNION ALL column, the colCollations element
2393 * will be set to InvalidOid, which may result in a runtime error
2394 * if something at a higher query level wants to use the column's
2395 * collation.)
2396 */
2397 rescolcoll = select_common_collation(pstate,
2398 list_make2(lcolnode, rcolnode),
2400
2401 /* emit results */
2402 op->colTypes = lappend_oid(op->colTypes, rescoltype);
2403 op->colTypmods = lappend_int(op->colTypmods, rescoltypmod);
2404 op->colCollations = lappend_oid(op->colCollations, rescolcoll);
2405
2406 /*
2407 * For all cases except UNION ALL, identify the grouping operators
2408 * (and, if available, sorting operators) that will be used to
2409 * eliminate duplicates.
2410 */
2412 {
2413 ParseCallbackState pcbstate;
2414
2415 setup_parser_errposition_callback(&pcbstate, pstate,
2416 bestlocation);
2417
2418 /*
2419 * If it's a recursive union, we need to require hashing
2420 * support.
2421 */
2422 op->groupClauses = lappend(op->groupClauses,
2423 makeSortGroupClauseForSetOp(rescoltype, recursive));
2424
2425 cancel_parser_errposition_callback(&pcbstate);
2426 }
2427
2428 /*
2429 * Construct a dummy tlist entry to return. We use a SetToDefault
2430 * node for the expression, since it carries exactly the fields
2431 * needed, but any other expression node type would do as well.
2432 */
2433 if (targetlist)
2434 {
2436 TargetEntry *restle;
2437
2438 rescolnode->typeId = rescoltype;
2439 rescolnode->typeMod = rescoltypmod;
2440 rescolnode->collation = rescolcoll;
2441 rescolnode->location = bestlocation;
2443 0, /* no need to set resno */
2444 NULL,
2445 false);
2446 *targetlist = lappend(*targetlist, restle);
2447 }
2448 }
2449
2451 }
2452}
Node * coerce_to_common_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *context)
Definition: parse_coerce.c:1572
int32 select_common_typmod(ParseState *pstate, List *exprs, Oid common_type)
Definition: parse_coerce.c:1644
Oid select_common_type(ParseState *pstate, List *exprs, const char *context, Node **which_expr)
Definition: parse_coerce.c:1342
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:2080
static void determineRecursiveColTypes(ParseState *pstate, Node *larg, List *nrtargetlist)
Definition: analyze.c:2459
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:2074
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 391 of file analyze.c.
392{
393 Query *result;
394
395#ifdef DEBUG_NODE_TESTS_ENABLED
396
397 /*
398 * We apply debug_raw_expression_coverage_test testing to basic DML
399 * statements; we can't just run it on everything because
400 * raw_expression_tree_walker() doesn't claim to handle utility
401 * statements.
402 */
403 if (Debug_raw_expression_coverage_test)
404 {
406 {
407 case T_SelectStmt:
408 case T_InsertStmt:
409 case T_UpdateStmt:
410 case T_DeleteStmt:
411 case T_MergeStmt:
412 (void) test_raw_expression_coverage(parseTree, NULL);
413 break;
414 default:
415 break;
416 }
417 }
418#endif /* DEBUG_NODE_TESTS_ENABLED */
419
420 /*
421 * Caution: when changing the set of statement types that have non-default
422 * processing here, see also stmt_requires_parse_analysis() and
423 * analyze_requires_snapshot().
424 */
426 {
427 /*
428 * Optimizable statements
429 */
430 case T_InsertStmt:
432 break;
433
434 case T_DeleteStmt:
436 break;
437
438 case T_UpdateStmt:
440 break;
441
442 case T_MergeStmt:
444 break;
445
446 case T_SelectStmt:
447 {
449
451 result = transformValuesClause(pstate, n);
453 result = transformSelectStmt(pstate, n);
454 else
455 result = transformSetOperationStmt(pstate, n);
456 }
457 break;
458
459 case T_ReturnStmt:
461 break;
462
463 case T_PLAssignStmt:
464 result = transformPLAssignStmt(pstate,
465 (PLAssignStmt *) parseTree);
466 break;
467
468 /*
469 * Special cases
470 */
471 case T_DeclareCursorStmt:
472 result = transformDeclareCursorStmt(pstate,
473 (DeclareCursorStmt *) parseTree);
474 break;
475
476 case T_ExplainStmt:
477 result = transformExplainStmt(pstate,
478 (ExplainStmt *) parseTree);
479 break;
480
481 case T_CreateTableAsStmt:
482 result = transformCreateTableAsStmt(pstate,
483 (CreateTableAsStmt *) parseTree);
484 break;
485
486 case T_CallStmt:
487 result = transformCallStmt(pstate,
488 (CallStmt *) parseTree);
489 break;
490
491 default:
492
493 /*
494 * other statements don't require any transformation; just return
495 * the original parsetree with a Query node plastered on top.
496 */
500 break;
501 }
502
503 /* Mark as original query until we learn differently */
504 result->querySource = QSRC_ORIGINAL;
505 result->canSetTag = true;
506 setQueryLocationAndLength(pstate, result, parseTree);
507
508 return result;
509}
Query * transformMergeStmt(ParseState *pstate, MergeStmt *stmt)
Definition: parse_merge.c:107
static void setQueryLocationAndLength(ParseState *pstate, Query *qry, Node *parseTree)
Definition: analyze.c:260
static Query * transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
Definition: analyze.c:633
static Query * transformReturnStmt(ParseState *pstate, ReturnStmt *stmt)
Definition: analyze.c:2513
static Query * transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt)
Definition: analyze.c:2847
static Query * transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt)
Definition: analyze.c:3241
static Query * transformCallStmt(ParseState *pstate, CallStmt *stmt)
Definition: analyze.c:3316
static Query * transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1823
static Query * transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
Definition: analyze.c:2544
static Query * transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1461
static Query * transformExplainStmt(ParseState *pstate, ExplainStmt *stmt)
Definition: analyze.c:3189
static Query * transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
Definition: analyze.c:3096
static Query * transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
Definition: analyze.c:705
static Query * transformValuesClause(ParseState *pstate, SelectStmt *stmt)
Definition: analyze.c:1604
Definition: parsenodes.h:3599
Definition: parsenodes.h:3388
Definition: parsenodes.h:3965
Definition: parsenodes.h:2270
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 327 of file analyze.c.
328{
329 Query *result;
330
331 /* Store RawStmt's length and location in pstate */
334
335 /* We're at top level, so allow SELECT INTO */
337
338 return result;
339}
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 2544 of file analyze.c.
2545{
2547 ParseNamespaceItem *nsitem;
2548 Node *qual;
2549
2552
2553 /* process the WITH clause independently of all else */
2555 {
2556 qry->hasRecursive = stmt->withClause->recursive;
2558 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
2559 }
2560
2562 stmt->relation->inh,
2563 true,
2564 ACL_UPDATE);
2565 nsitem = pstate->p_target_nsitem;
2566
2567 /* subqueries in FROM cannot access the result relation */
2570
2571 /*
2572 * the FROM clause is non-standard SQL syntax. We used to be able to do
2573 * this with REPLACE in POSTQUEL so we keep the feature.
2574 */
2576
2577 /* remaining clauses can reference the result relation normally */
2580
2583
2585 EXPR_KIND_RETURNING);
2586
2587 /*
2588 * Now we are done with SELECT-like processing, and can get on with
2589 * transforming the target list to match the UPDATE target columns.
2590 */
2592
2594 qry->rteperminfos = pstate->p_rteperminfos;
2596
2597 qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2598 qry->hasSubLinks = pstate->p_hasSubLinks;
2599
2600 assign_query_collations(pstate, qry);
2601
2602 return qry;
2603}
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 2610 of file analyze.c.
2611{
2613 RTEPermissionInfo *target_perminfo;
2614 ListCell *orig_tl;
2615 ListCell *tl;
2616
2617 tlist = transformTargetList(pstate, origTlist,
2618 EXPR_KIND_UPDATE_SOURCE);
2619
2620 /* Prepare to assign non-conflicting resnos to resjunk attributes */
2623
2624 /* Prepare non-junk columns for assignment to target table */
2626 orig_tl = list_head(origTlist);
2627
2628 foreach(tl, tlist)
2629 {
2631 ResTarget *origTarget;
2632 int attrno;
2633
2634 if (tle->resjunk)
2635 {
2636 /*
2637 * Resjunk nodes need no additional processing, but be sure they
2638 * have resnos that do not match any target columns; else rewriter
2639 * or planner might get confused. They don't need a resname
2640 * either.
2641 */
2643 tle->resname = NULL;
2644 continue;
2645 }
2646 if (orig_tl == NULL)
2649
2654 (errcode(ERRCODE_UNDEFINED_COLUMN),
2656 origTarget->name,
2662
2664 attrno,
2665 origTarget->indirection,
2666 origTarget->location);
2667
2668 /* Mark the target column as requiring update permissions */
2670 attrno - FirstLowInvalidHeapAttributeNumber);
2671
2672 orig_tl = lnext(origTlist, orig_tl);
2673 }
2674 if (orig_tl != NULL)
2676
2677 return tlist;
2678}
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
Definition: parse_relation.c:3589
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 1604 of file analyze.c.
1605{
1611 List **colexprs = NULL;
1612 int sublist_length = -1;
1613 bool lateral = false;
1614 ParseNamespaceItem *nsitem;
1615 ListCell *lc;
1616 ListCell *lc2;
1618
1620
1621 /* Most SELECT stuff doesn't apply in a VALUES clause */
1631
1632 /* process the WITH clause independently of all else */
1634 {
1635 qry->hasRecursive = stmt->withClause->recursive;
1637 qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1638 }
1639
1640 /*
1641 * For each row of VALUES, transform the raw expressions.
1642 *
1643 * Note that the intermediate representation we build is column-organized
1644 * not row-organized. That simplifies the type and collation processing
1645 * below.
1646 */
1648 {
1650
1651 /*
1652 * Do basic expression transformation (same as a ROW() expr, but here
1653 * we disallow SetToDefault)
1654 */
1655 sublist = transformExpressionList(pstate, sublist,
1657
1658 /*
1659 * All the sublists must be the same length, *after* transformation
1660 * (which might expand '*' into multiple items). The VALUES RTE can't
1661 * handle anything different.
1662 */
1663 if (sublist_length < 0)
1664 {
1665 /* Remember post-transformation length of first sublist */
1666 sublist_length = list_length(sublist);
1667 /* and allocate array for per-column lists */
1669 }
1671 {
1673 (errcode(ERRCODE_SYNTAX_ERROR),
1675 parser_errposition(pstate,
1677 }
1678
1679 /* Build per-column expression lists */
1680 i = 0;
1681 foreach(lc2, sublist)
1682 {
1684
1686 i++;
1687 }
1688
1689 /* Release sub-list's cells to save memory */
1690 list_free(sublist);
1691
1692 /* Prepare an exprsLists element for this row */
1694 }
1695
1696 /*
1697 * Now resolve the common types of the columns, and coerce everything to
1698 * those types. Then identify the common typmod and common collation, if
1699 * any, of each column.
1700 *
1701 * We must do collation processing now because (1) assign_query_collations
1702 * doesn't process rangetable entries, and (2) we need to label the VALUES
1703 * RTE with column collations for use in the outer query. We don't
1704 * consider conflict of implicit collations to be an error here; instead
1705 * the column will just show InvalidOid as its collation, and you'll get a
1706 * failure later if that results in failure to resolve a collation.
1707 *
1708 * Note we modify the per-column expression lists in-place.
1709 */
1711 {
1712 Oid coltype;
1713 int32 coltypmod;
1714 Oid colcoll;
1715
1717
1719 {
1721
1723 lfirst(lc) = col;
1724 }
1725
1728
1729 coltypes = lappend_oid(coltypes, coltype);
1730 coltypmods = lappend_int(coltypmods, coltypmod);
1731 colcollations = lappend_oid(colcollations, colcoll);
1732 }
1733
1734 /*
1735 * Finally, rearrange the coerced expressions into row-organized lists.
1736 */
1738 {
1740 {
1743
1744 sublist = lappend(sublist, col);
1745 lfirst(lc2) = sublist;
1746 }
1748 }
1749
1750 /*
1751 * Ordinarily there can't be any current-level Vars in the expression
1752 * lists, because the namespace was empty ... but if we're inside CREATE
1753 * RULE, then NEW/OLD references might appear. In that case we have to
1754 * mark the VALUES RTE as LATERAL.
1755 */
1758 lateral = true;
1759
1760 /*
1761 * Generate the VALUES RTE
1762 */
1763 nsitem = addRangeTableEntryForValues(pstate, exprsLists,
1764 coltypes, coltypmods, colcollations,
1765 NULL, lateral, true);
1767
1768 /*
1769 * Generate a targetlist as though expanding "*"
1770 */
1773
1774 /*
1775 * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a
1776 * VALUES, so cope.
1777 */
1779 stmt->sortClause,
1780 &qry->targetList,
1781 EXPR_KIND_ORDER_BY,
1782 false /* allow SQL92 rules */ );
1783
1786 stmt->limitOption);
1789 stmt->limitOption);
1791
1794 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1795 /*------
1796 translator: %s is a SQL row locking clause such as FOR UPDATE */
1800
1802 qry->rteperminfos = pstate->p_rteperminfos;
1804
1805 qry->hasSubLinks = pstate->p_hasSubLinks;
1806
1807 assign_query_collations(pstate, qry);
1808
1809 return qry;
1810}
List * expandNSItemAttrs(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, bool require_col_privs, int location)
Definition: parse_relation.c:3292
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().
