diff options
Diffstat (limited to '')
| -rw-r--r-- | src/backend/parser/analyze.c | 3436 |
1 files changed, 3436 insertions, 0 deletions
diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c new file mode 100644 index 0000000..333be34 --- /dev/null +++ b/src/backend/parser/analyze.c @@ -0,0 +1,3436 @@ +/*------------------------------------------------------------------------- + * + * analyze.c + * transform the raw parse tree into a query tree + * + * For optimizable statements, we are careful to obtain a suitable lock on + * each referenced table, and other modules of the backend preserve or + * re-obtain these locks before depending on the results. It is therefore + * okay to do significant semantic analysis of these statements. For + * utility commands, no locks are obtained here (and if they were, we could + * not be sure we'd still have them at execution). Hence the general rule + * for utility commands is to just dump them into a Query node untransformed. + * DECLARE CURSOR, EXPLAIN, and CREATE TABLE AS are exceptions because they + * contain optimizable statements, which we should transform. + * + * + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/backend/parser/analyze.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/sysattr.h" +#include "catalog/pg_proc.h" +#include "catalog/pg_type.h" +#include "miscadmin.h" +#include "nodes/makefuncs.h" +#include "nodes/nodeFuncs.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_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 "rewrite/rewriteManip.h" +#include "utils/backend_status.h" +#include "utils/builtins.h" +#include "utils/guc.h" +#include "utils/queryjumble.h" +#include "utils/rel.h" +#include "utils/syscache.h" + + +/* Hook for plugins to get control at end of parse analysis */ +post_parse_analyze_hook_type post_parse_analyze_hook = NULL; + +static Query *transformOptionalSelectInto(ParseState *pstate, Node *parseTree); +static Query *transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt); +static Query *transformInsertStmt(ParseState *pstate, InsertStmt *stmt); +static List *transformInsertRow(ParseState *pstate, List *exprlist, + List *stmtcols, List *icolumns, List *attrnos, + bool strip_indirection); +static OnConflictExpr *transformOnConflictClause(ParseState *pstate, + OnConflictClause *onConflictClause); +static int count_rowexpr_columns(ParseState *pstate, Node *expr); +static Query *transformSelectStmt(ParseState *pstate, SelectStmt *stmt); +static Query *transformValuesClause(ParseState *pstate, SelectStmt *stmt); +static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt); +static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, + bool isTopLevel, List **targetlist); +static void determineRecursiveColTypes(ParseState *pstate, + Node *larg, List *nrtargetlist); +static Query *transformReturnStmt(ParseState *pstate, ReturnStmt *stmt); +static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt); +static List *transformReturningList(ParseState *pstate, List *returningList); +static List *transformUpdateTargetList(ParseState *pstate, + List *targetList); +static Query *transformPLAssignStmt(ParseState *pstate, + PLAssignStmt *stmt); +static Query *transformDeclareCursorStmt(ParseState *pstate, + DeclareCursorStmt *stmt); +static Query *transformExplainStmt(ParseState *pstate, + ExplainStmt *stmt); +static Query *transformCreateTableAsStmt(ParseState *pstate, + CreateTableAsStmt *stmt); +static Query *transformCallStmt(ParseState *pstate, + CallStmt *stmt); +static void transformLockingClause(ParseState *pstate, Query *qry, + LockingClause *lc, bool pushedDown); +#ifdef RAW_EXPRESSION_COVERAGE_TEST +static bool test_raw_expression_coverage(Node *node, void *context); +#endif + + +/* + * parse_analyze + * Analyze a raw parse tree and transform it to Query form. + * + * Optionally, information about $n parameter types can be supplied. + * References to $n indexes not defined by paramTypes[] are disallowed. + * + * The result is a Query node. Optimizable statements require considerable + * transformation, while utility-type statements are simply hung off + * a dummy CMD_UTILITY Query node. + */ +Query * +parse_analyze(RawStmt *parseTree, const char *sourceText, + Oid *paramTypes, int numParams, + QueryEnvironment *queryEnv) +{ + ParseState *pstate = make_parsestate(NULL); + Query *query; + JumbleState *jstate = NULL; + + Assert(sourceText != NULL); /* required as of 8.4 */ + + pstate->p_sourcetext = sourceText; + + if (numParams > 0) + parse_fixed_parameters(pstate, paramTypes, numParams); + + pstate->p_queryEnv = queryEnv; + + query = transformTopLevelStmt(pstate, parseTree); + + if (IsQueryIdEnabled()) + jstate = JumbleQuery(query, sourceText); + + if (post_parse_analyze_hook) + (*post_parse_analyze_hook) (pstate, query, jstate); + + free_parsestate(pstate); + + pgstat_report_query_id(query->queryId, false); + + return query; +} + +/* + * parse_analyze_varparams + * + * This variant is used when it's okay to deduce information about $n + * symbol datatypes from context. The passed-in paramTypes[] array can + * be modified or enlarged (via repalloc). + */ +Query * +parse_analyze_varparams(RawStmt *parseTree, const char *sourceText, + Oid **paramTypes, int *numParams) +{ + ParseState *pstate = make_parsestate(NULL); + Query *query; + JumbleState *jstate = NULL; + + Assert(sourceText != NULL); /* required as of 8.4 */ + + pstate->p_sourcetext = sourceText; + + parse_variable_parameters(pstate, paramTypes, numParams); + + query = transformTopLevelStmt(pstate, parseTree); + + /* make sure all is well with parameter types */ + check_variable_parameters(pstate, query); + + if (IsQueryIdEnabled()) + jstate = JumbleQuery(query, sourceText); + + if (post_parse_analyze_hook) + (*post_parse_analyze_hook) (pstate, query, jstate); + + free_parsestate(pstate); + + pgstat_report_query_id(query->queryId, false); + + return query; +} + +/* + * parse_sub_analyze + * Entry point for recursively analyzing a sub-statement. + */ +Query * +parse_sub_analyze(Node *parseTree, ParseState *parentParseState, + CommonTableExpr *parentCTE, + bool locked_from_parent, + bool resolve_unknowns) +{ + ParseState *pstate = make_parsestate(parentParseState); + Query *query; + + pstate->p_parent_cte = parentCTE; + pstate->p_locked_from_parent = locked_from_parent; + pstate->p_resolve_unknowns = resolve_unknowns; + + query = transformStmt(pstate, parseTree); + + free_parsestate(pstate); + + return query; +} + +/* + * transformTopLevelStmt - + * transform a Parse tree into a Query tree. + * + * This function is just responsible for transferring statement location data + * from the RawStmt into the finished Query. + */ +Query * +transformTopLevelStmt(ParseState *pstate, RawStmt *parseTree) +{ + Query *result; + + /* We're at top level, so allow SELECT INTO */ + result = transformOptionalSelectInto(pstate, parseTree->stmt); + + result->stmt_location = parseTree->stmt_location; + result->stmt_len = parseTree->stmt_len; + + return result; +} + +/* + * transformOptionalSelectInto - + * If SELECT has INTO, convert it to CREATE TABLE AS. + * + * The only thing we do here that we don't do in transformStmt() is to + * convert SELECT ... INTO into CREATE TABLE AS. Since utility statements + * aren't allowed within larger statements, this is only allowed at the top + * of the parse tree, and so we only try it before entering the recursive + * transformStmt() processing. + */ +static Query * +transformOptionalSelectInto(ParseState *pstate, Node *parseTree) +{ + if (IsA(parseTree, SelectStmt)) + { + SelectStmt *stmt = (SelectStmt *) parseTree; + + /* If it's a set-operation tree, drill down to leftmost SelectStmt */ + while (stmt && stmt->op != SETOP_NONE) + stmt = stmt->larg; + Assert(stmt && IsA(stmt, SelectStmt) && stmt->larg == NULL); + + if (stmt->intoClause) + { + CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt); + + ctas->query = parseTree; + ctas->into = stmt->intoClause; + ctas->objtype = OBJECT_TABLE; + ctas->is_select_into = true; + + /* + * Remove the intoClause from the SelectStmt. This makes it safe + * for transformSelectStmt to complain if it finds intoClause set + * (implying that the INTO appeared in a disallowed place). + */ + stmt->intoClause = NULL; + + parseTree = (Node *) ctas; + } + } + + return transformStmt(pstate, parseTree); +} + +/* + * transformStmt - + * recursively transform a Parse tree into a Query tree. + */ +Query * +transformStmt(ParseState *pstate, Node *parseTree) +{ + Query *result; + + /* + * We apply RAW_EXPRESSION_COVERAGE_TEST testing to basic DML statements; + * we can't just run it on everything because raw_expression_tree_walker() + * doesn't claim to handle utility statements. + */ +#ifdef RAW_EXPRESSION_COVERAGE_TEST + switch (nodeTag(parseTree)) + { + case T_SelectStmt: + case T_InsertStmt: + case T_UpdateStmt: + case T_DeleteStmt: + (void) test_raw_expression_coverage(parseTree, NULL); + break; + default: + break; + } +#endif /* RAW_EXPRESSION_COVERAGE_TEST */ + + switch (nodeTag(parseTree)) + { + /* + * Optimizable statements + */ + case T_InsertStmt: + result = transformInsertStmt(pstate, (InsertStmt *) parseTree); + break; + + case T_DeleteStmt: + result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree); + break; + + case T_UpdateStmt: + result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree); + break; + + case T_SelectStmt: + { + SelectStmt *n = (SelectStmt *) parseTree; + + if (n->valuesLists) + result = transformValuesClause(pstate, n); + else if (n->op == SETOP_NONE) + result = transformSelectStmt(pstate, n); + else + result = transformSetOperationStmt(pstate, n); + } + break; + + case T_ReturnStmt: + result = transformReturnStmt(pstate, (ReturnStmt *) parseTree); + break; + + case T_PLAssignStmt: + result = transformPLAssignStmt(pstate, + (PLAssignStmt *) parseTree); + break; + + /* + * Special cases + */ + case T_DeclareCursorStmt: + result = transformDeclareCursorStmt(pstate, + (DeclareCursorStmt *) parseTree); + break; + + case T_ExplainStmt: + result = transformExplainStmt(pstate, + (ExplainStmt *) parseTree); + break; + + case T_CreateTableAsStmt: + result = transformCreateTableAsStmt(pstate, + (CreateTableAsStmt *) parseTree); + break; + + case T_CallStmt: + result = transformCallStmt(pstate, + (CallStmt *) parseTree); + break; + + default: + + /* + * other statements don't require any transformation; just return + * the original parsetree with a Query node plastered on top. + */ + result = makeNode(Query); + result->commandType = CMD_UTILITY; + result->utilityStmt = (Node *) parseTree; + break; + } + + /* Mark as original query until we learn differently */ + result->querySource = QSRC_ORIGINAL; + result->canSetTag = true; + + return result; +} + +/* + * analyze_requires_snapshot + * Returns true if a snapshot must be set before doing parse analysis + * on the given raw parse tree. + * + * Classification here should match transformStmt(). + */ +bool +analyze_requires_snapshot(RawStmt *parseTree) +{ + bool result; + + switch (nodeTag(parseTree->stmt)) + { + /* + * Optimizable statements + */ + case T_InsertStmt: + case T_DeleteStmt: + case T_UpdateStmt: + case T_SelectStmt: + case T_PLAssignStmt: + result = true; + break; + + /* + * Special cases + */ + case T_DeclareCursorStmt: + case T_ExplainStmt: + case T_CreateTableAsStmt: + /* yes, because we must analyze the contained statement */ + result = true; + break; + + default: + /* other utility statements don't have any real parse analysis */ + result = false; + break; + } + + return result; +} + +/* + * transformDeleteStmt - + * transforms a Delete Statement + */ +static Query * +transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt) +{ + Query *qry = makeNode(Query); + ParseNamespaceItem *nsitem; + Node *qual; + + qry->commandType = CMD_DELETE; + + /* process the WITH clause independently of all else */ + if (stmt->withClause) + { + qry->hasRecursive = stmt->withClause->recursive; + qry->cteList = transformWithClause(pstate, stmt->withClause); + qry->hasModifyingCTE = pstate->p_hasModifyingCTE; + } + + /* set up range table with just the result rel */ + qry->resultRelation = setTargetTable(pstate, stmt->relation, + stmt->relation->inh, + true, + ACL_DELETE); + nsitem = pstate->p_target_nsitem; + + /* there's no DISTINCT in DELETE */ + qry->distinctClause = NIL; + + /* subqueries in USING cannot access the result relation */ + nsitem->p_lateral_only = true; + nsitem->p_lateral_ok = false; + + /* + * The USING clause is non-standard SQL syntax, and is equivalent in + * functionality to the FROM list that can be specified for UPDATE. The + * USING keyword is used rather than FROM because FROM is already a + * keyword in the DELETE syntax. + */ + transformFromClause(pstate, stmt->usingClause); + + /* remaining clauses can reference the result relation normally */ + nsitem->p_lateral_only = false; + nsitem->p_lateral_ok = true; + + qual = transformWhereClause(pstate, stmt->whereClause, + EXPR_KIND_WHERE, "WHERE"); + + qry->returningList = transformReturningList(pstate, stmt->returningList); + + /* done building the range table and jointree */ + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, qual); + + qry->hasSubLinks = pstate->p_hasSubLinks; + qry->hasWindowFuncs = pstate->p_hasWindowFuncs; + qry->hasTargetSRFs = pstate->p_hasTargetSRFs; + qry->hasAggs = pstate->p_hasAggs; + + assign_query_collations(pstate, qry); + + /* this must be done after collations, for reliable comparison of exprs */ + if (pstate->p_hasAggs) + parseCheckAggregates(pstate, qry); + + return qry; +} + +/* + * transformInsertStmt - + * transform an Insert Statement + */ +static Query * +transformInsertStmt(ParseState *pstate, InsertStmt *stmt) +{ + Query *qry = makeNode(Query); + SelectStmt *selectStmt = (SelectStmt *) stmt->selectStmt; + List *exprList = NIL; + bool isGeneralSelect; + List *sub_rtable; + List *sub_namespace; + List *icolumns; + List *attrnos; + ParseNamespaceItem *nsitem; + RangeTblEntry *rte; + ListCell *icols; + ListCell *attnos; + ListCell *lc; + bool isOnConflictUpdate; + AclMode targetPerms; + + /* There can't be any outer WITH to worry about */ + Assert(pstate->p_ctenamespace == NIL); + + qry->commandType = CMD_INSERT; + pstate->p_is_insert = true; + + /* process the WITH clause independently of all else */ + if (stmt->withClause) + { + qry->hasRecursive = stmt->withClause->recursive; + qry->cteList = transformWithClause(pstate, stmt->withClause); + qry->hasModifyingCTE = pstate->p_hasModifyingCTE; + } + + qry->override = stmt->override; + + isOnConflictUpdate = (stmt->onConflictClause && + stmt->onConflictClause->action == ONCONFLICT_UPDATE); + + /* + * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL), + * VALUES list, or general SELECT input. We special-case VALUES, both for + * efficiency and so we can handle DEFAULT specifications. + * + * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a + * VALUES clause. If we have any of those, treat it as a general SELECT; + * so it will work, but you can't use DEFAULT items together with those. + */ + isGeneralSelect = (selectStmt && (selectStmt->valuesLists == NIL || + selectStmt->sortClause != NIL || + selectStmt->limitOffset != NULL || + selectStmt->limitCount != NULL || + selectStmt->lockingClause != NIL || + selectStmt->withClause != NULL)); + + /* + * If a non-nil rangetable/namespace was passed in, and we are doing + * INSERT/SELECT, arrange to pass the rangetable/namespace down to the + * SELECT. This can only happen if we are inside a CREATE RULE, and in + * that case we want the rule's OLD and NEW rtable entries to appear as + * part of the SELECT's rtable, not as outer references for it. (Kluge!) + * The SELECT's joinlist is not affected however. We must do this before + * adding the target table to the INSERT's rtable. + */ + if (isGeneralSelect) + { + sub_rtable = pstate->p_rtable; + pstate->p_rtable = NIL; + sub_namespace = pstate->p_namespace; + pstate->p_namespace = NIL; + } + else + { + sub_rtable = NIL; /* not used, but keep compiler quiet */ + sub_namespace = NIL; + } + + /* + * Must get write lock on INSERT target table before scanning SELECT, else + * we will grab the wrong kind of initial lock if the target table is also + * mentioned in the SELECT part. Note that the target table is not added + * to the joinlist or namespace. + */ + targetPerms = ACL_INSERT; + if (isOnConflictUpdate) + targetPerms |= ACL_UPDATE; + qry->resultRelation = setTargetTable(pstate, stmt->relation, + false, false, targetPerms); + + /* Validate stmt->cols list, or build default list if no list given */ + icolumns = checkInsertTargets(pstate, stmt->cols, &attrnos); + Assert(list_length(icolumns) == list_length(attrnos)); + + /* + * Determine which variant of INSERT we have. + */ + if (selectStmt == NULL) + { + /* + * We have INSERT ... DEFAULT VALUES. We can handle this case by + * emitting an empty targetlist --- all columns will be defaulted when + * the planner expands the targetlist. + */ + exprList = NIL; + } + else if (isGeneralSelect) + { + /* + * We make the sub-pstate a child of the outer pstate so that it can + * see any Param definitions supplied from above. Since the outer + * pstate's rtable and namespace are presently empty, there are no + * side-effects of exposing names the sub-SELECT shouldn't be able to + * see. + */ + ParseState *sub_pstate = make_parsestate(pstate); + Query *selectQuery; + + /* + * Process the source SELECT. + * + * It is important that this be handled just like a standalone SELECT; + * otherwise the behavior of SELECT within INSERT might be different + * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had + * bugs of just that nature...) + * + * The sole exception is that we prevent resolving unknown-type + * outputs as TEXT. This does not change the semantics since if the + * column type matters semantically, it would have been resolved to + * something else anyway. Doing this lets us resolve such outputs as + * the target column's type, which we handle below. + */ + sub_pstate->p_rtable = sub_rtable; + sub_pstate->p_joinexprs = NIL; /* sub_rtable has no joins */ + sub_pstate->p_namespace = sub_namespace; + sub_pstate->p_resolve_unknowns = false; + + selectQuery = transformStmt(sub_pstate, stmt->selectStmt); + + free_parsestate(sub_pstate); + + /* The grammar should have produced a SELECT */ + if (!IsA(selectQuery, Query) || + selectQuery->commandType != CMD_SELECT) + elog(ERROR, "unexpected non-SELECT command in INSERT ... SELECT"); + + /* + * Make the source be a subquery in the INSERT's rangetable, and add + * it to the INSERT's joinlist (but not the namespace). + */ + nsitem = addRangeTableEntryForSubquery(pstate, + selectQuery, + makeAlias("*SELECT*", NIL), + false, + false); + addNSItemToQuery(pstate, nsitem, true, false, false); + + /*---------- + * Generate an expression list for the INSERT that selects all the + * non-resjunk columns from the subquery. (INSERT's tlist must be + * separate from the subquery's tlist because we may add columns, + * insert datatype coercions, etc.) + * + * HACK: unknown-type constants and params in the SELECT's targetlist + * are copied up as-is rather than being referenced as subquery + * outputs. This is to ensure that when we try to coerce them to + * the target column's datatype, the right things happen (see + * special cases in coerce_type). Otherwise, this fails: + * INSERT INTO foo SELECT 'bar', ... FROM baz + *---------- + */ + exprList = NIL; + foreach(lc, selectQuery->targetList) + { + TargetEntry *tle = (TargetEntry *) lfirst(lc); + Expr *expr; + + if (tle->resjunk) + continue; + if (tle->expr && + (IsA(tle->expr, Const) || IsA(tle->expr, Param)) && + exprType((Node *) tle->expr) == UNKNOWNOID) + expr = tle->expr; + else + { + Var *var = makeVarFromTargetEntry(nsitem->p_rtindex, tle); + + var->location = exprLocation((Node *) tle->expr); + expr = (Expr *) var; + } + exprList = lappend(exprList, expr); + } + + /* Prepare row for assignment to target table */ + exprList = transformInsertRow(pstate, exprList, + stmt->cols, + icolumns, attrnos, + false); + } + else if (list_length(selectStmt->valuesLists) > 1) + { + /* + * Process INSERT ... VALUES with multiple VALUES sublists. We + * generate a VALUES RTE holding the transformed expression lists, and + * build up a targetlist containing Vars that reference the VALUES + * RTE. + */ + List *exprsLists = NIL; + List *coltypes = NIL; + List *coltypmods = NIL; + List *colcollations = NIL; + int sublist_length = -1; + bool lateral = false; + + Assert(selectStmt->intoClause == NULL); + + foreach(lc, selectStmt->valuesLists) + { + List *sublist = (List *) lfirst(lc); + + /* + * Do basic expression transformation (same as a ROW() expr, but + * allow SetToDefault at top level) + */ + sublist = transformExpressionList(pstate, sublist, + EXPR_KIND_VALUES, true); + + /* + * All the sublists must be the same length, *after* + * transformation (which might expand '*' into multiple items). + * The VALUES RTE can't handle anything different. + */ + if (sublist_length < 0) + { + /* Remember post-transformation length of first sublist */ + sublist_length = list_length(sublist); + } + else if (sublist_length != list_length(sublist)) + { + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("VALUES lists must all be the same length"), + parser_errposition(pstate, + exprLocation((Node *) sublist)))); + } + + /* + * Prepare row for assignment to target table. We process any + * indirection on the target column specs normally but then strip + * off the resulting field/array assignment nodes, since we don't + * want the parsed statement to contain copies of those in each + * VALUES row. (It's annoying to have to transform the + * indirection specs over and over like this, but avoiding it + * would take some really messy refactoring of + * transformAssignmentIndirection.) + */ + sublist = transformInsertRow(pstate, sublist, + stmt->cols, + icolumns, attrnos, + true); + + /* + * We must assign collations now because assign_query_collations + * doesn't process rangetable entries. We just assign all the + * collations independently in each row, and don't worry about + * whether they are consistent vertically. The outer INSERT query + * isn't going to care about the collations of the VALUES columns, + * so it's not worth the effort to identify a common collation for + * each one here. (But note this does have one user-visible + * consequence: INSERT ... VALUES won't complain about conflicting + * explicit COLLATEs in a column, whereas the same VALUES + * construct in another context would complain.) + */ + assign_list_collations(pstate, sublist); + + exprsLists = lappend(exprsLists, sublist); + } + + /* + * Construct column type/typmod/collation lists for the VALUES RTE. + * Every expression in each column has been coerced to the type/typmod + * of the corresponding target column or subfield, so it's sufficient + * to look at the exprType/exprTypmod of the first row. We don't care + * about the collation labeling, so just fill in InvalidOid for that. + */ + foreach(lc, (List *) linitial(exprsLists)) + { + Node *val = (Node *) lfirst(lc); + + coltypes = lappend_oid(coltypes, exprType(val)); + coltypmods = lappend_int(coltypmods, exprTypmod(val)); + colcollations = lappend_oid(colcollations, InvalidOid); + } + + /* + * Ordinarily there can't be any current-level Vars in the expression + * lists, because the namespace was empty ... but if we're inside + * CREATE RULE, then NEW/OLD references might appear. In that case we + * have to mark the VALUES RTE as LATERAL. + */ + if (list_length(pstate->p_rtable) != 1 && + contain_vars_of_level((Node *) exprsLists, 0)) + lateral = true; + + /* + * Generate the VALUES RTE + */ + nsitem = addRangeTableEntryForValues(pstate, exprsLists, + coltypes, coltypmods, colcollations, + NULL, lateral, true); + addNSItemToQuery(pstate, nsitem, true, false, false); + + /* + * Generate list of Vars referencing the RTE + */ + exprList = expandNSItemVars(nsitem, 0, -1, NULL); + + /* + * Re-apply any indirection on the target column specs to the Vars + */ + exprList = transformInsertRow(pstate, exprList, + stmt->cols, + icolumns, attrnos, + false); + } + else + { + /* + * Process INSERT ... VALUES with a single VALUES sublist. We treat + * this case separately for efficiency. The sublist is just computed + * directly as the Query's targetlist, with no VALUES RTE. So it + * works just like a SELECT without any FROM. + */ + List *valuesLists = selectStmt->valuesLists; + + Assert(list_length(valuesLists) == 1); + Assert(selectStmt->intoClause == NULL); + + /* + * Do basic expression transformation (same as a ROW() expr, but allow + * SetToDefault at top level) + */ + exprList = transformExpressionList(pstate, + (List *) linitial(valuesLists), + EXPR_KIND_VALUES_SINGLE, + true); + + /* Prepare row for assignment to target table */ + exprList = transformInsertRow(pstate, exprList, + stmt->cols, + icolumns, attrnos, + false); + } + + /* + * Generate query's target list using the computed list of expressions. + * Also, mark all the target columns as needing insert permissions. + */ + rte = pstate->p_target_nsitem->p_rte; + qry->targetList = NIL; + Assert(list_length(exprList) <= list_length(icolumns)); + forthree(lc, exprList, icols, icolumns, attnos, attrnos) + { + Expr *expr = (Expr *) lfirst(lc); + ResTarget *col = lfirst_node(ResTarget, icols); + AttrNumber attr_num = (AttrNumber) lfirst_int(attnos); + TargetEntry *tle; + + tle = makeTargetEntry(expr, + attr_num, + col->name, + false); + qry->targetList = lappend(qry->targetList, tle); + + rte->insertedCols = bms_add_member(rte->insertedCols, + attr_num - FirstLowInvalidHeapAttributeNumber); + } + + /* + * If we have any clauses yet to process, set the query namespace to + * contain only the target relation, removing any entries added in a + * sub-SELECT or VALUES list. + */ + if (stmt->onConflictClause || stmt->returningList) + { + pstate->p_namespace = NIL; + addNSItemToQuery(pstate, pstate->p_target_nsitem, + false, true, true); + } + + /* Process ON CONFLICT, if any. */ + if (stmt->onConflictClause) + qry->onConflict = transformOnConflictClause(pstate, + stmt->onConflictClause); + + /* Process RETURNING, if any. */ + if (stmt->returningList) + qry->returningList = transformReturningList(pstate, + stmt->returningList); + + /* done building the range table and jointree */ + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, NULL); + + qry->hasTargetSRFs = pstate->p_hasTargetSRFs; + qry->hasSubLinks = pstate->p_hasSubLinks; + + assign_query_collations(pstate, qry); + + return qry; +} + +/* + * Prepare an INSERT row for assignment to the target table. + * + * exprlist: transformed expressions for source values; these might come from + * a VALUES row, or be Vars referencing a sub-SELECT or VALUES RTE output. + * stmtcols: original target-columns spec for INSERT (we just test for NIL) + * icolumns: effective target-columns spec (list of ResTarget) + * attrnos: integer column numbers (must be same length as icolumns) + * strip_indirection: if true, remove any field/array assignment nodes + */ +static List * +transformInsertRow(ParseState *pstate, List *exprlist, + List *stmtcols, List *icolumns, List *attrnos, + bool strip_indirection) +{ + List *result; + ListCell *lc; + ListCell *icols; + ListCell *attnos; + + /* + * Check length of expr list. It must not have more expressions than + * there are target columns. We allow fewer, but only if no explicit + * columns list was given (the remaining columns are implicitly + * defaulted). Note we must check this *after* transformation because + * that could expand '*' into multiple items. + */ + if (list_length(exprlist) > list_length(icolumns)) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("INSERT has more expressions than target columns"), + parser_errposition(pstate, + exprLocation(list_nth(exprlist, + list_length(icolumns)))))); + if (stmtcols != NIL && + list_length(exprlist) < list_length(icolumns)) + { + /* + * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ... + * where the user accidentally created a RowExpr instead of separate + * columns. Add a suitable hint if that seems to be the problem, + * because the main error message is quite misleading for this case. + * (If there's no stmtcols, you'll get something about data type + * mismatch, which is less misleading so we don't worry about giving a + * hint in that case.) + */ + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("INSERT has more target columns than expressions"), + ((list_length(exprlist) == 1 && + count_rowexpr_columns(pstate, linitial(exprlist)) == + list_length(icolumns)) ? + 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), + parser_errposition(pstate, + exprLocation(list_nth(icolumns, + list_length(exprlist)))))); + } + + /* + * Prepare columns for assignment to target table. + */ + result = NIL; + forthree(lc, exprlist, icols, icolumns, attnos, attrnos) + { + Expr *expr = (Expr *) lfirst(lc); + ResTarget *col = lfirst_node(ResTarget, icols); + int attno = lfirst_int(attnos); + + expr = transformAssignedExpr(pstate, expr, + EXPR_KIND_INSERT_TARGET, + col->name, + attno, + col->indirection, + col->location); + + if (strip_indirection) + { + while (expr) + { + if (IsA(expr, FieldStore)) + { + FieldStore *fstore = (FieldStore *) expr; + + expr = (Expr *) linitial(fstore->newvals); + } + else if (IsA(expr, SubscriptingRef)) + { + SubscriptingRef *sbsref = (SubscriptingRef *) expr; + + if (sbsref->refassgnexpr == NULL) + break; + + expr = sbsref->refassgnexpr; + } + else + break; + } + } + + result = lappend(result, expr); + } + + return result; +} + +/* + * transformOnConflictClause - + * transforms an OnConflictClause in an INSERT + */ +static OnConflictExpr * +transformOnConflictClause(ParseState *pstate, + OnConflictClause *onConflictClause) +{ + ParseNamespaceItem *exclNSItem = NULL; + List *arbiterElems; + Node *arbiterWhere; + Oid arbiterConstraint; + List *onConflictSet = NIL; + Node *onConflictWhere = NULL; + int exclRelIndex = 0; + List *exclRelTlist = NIL; + OnConflictExpr *result; + + /* + * If this is ON CONFLICT ... UPDATE, first create the range table entry + * for the EXCLUDED pseudo relation, so that that will be present while + * processing arbiter expressions. (You can't actually reference it from + * there, but this provides a useful error message if you try.) + */ + if (onConflictClause->action == ONCONFLICT_UPDATE) + { + Relation targetrel = pstate->p_target_relation; + RangeTblEntry *exclRte; + + exclNSItem = addRangeTableEntryForRelation(pstate, + targetrel, + RowExclusiveLock, + makeAlias("excluded", NIL), + false, false); + exclRte = exclNSItem->p_rte; + exclRelIndex = exclNSItem->p_rtindex; + + /* + * relkind is set to composite to signal that we're not dealing with + * an actual relation, and no permission checks are required on it. + * (We'll check the actual target relation, instead.) + */ + exclRte->relkind = RELKIND_COMPOSITE_TYPE; + exclRte->requiredPerms = 0; + /* other permissions fields in exclRte are already empty */ + + /* Create EXCLUDED rel's targetlist for use by EXPLAIN */ + exclRelTlist = BuildOnConflictExcludedTargetlist(targetrel, + exclRelIndex); + } + + /* Process the arbiter clause, ON CONFLICT ON (...) */ + transformOnConflictArbiter(pstate, onConflictClause, &arbiterElems, + &arbiterWhere, &arbiterConstraint); + + /* Process DO UPDATE */ + if (onConflictClause->action == ONCONFLICT_UPDATE) + { + /* + * Expressions in the UPDATE targetlist need to be handled like UPDATE + * not INSERT. We don't need to save/restore this because all INSERT + * expressions have been parsed already. + */ + pstate->p_is_insert = false; + + /* + * Add the EXCLUDED pseudo relation to the query namespace, making it + * available in the UPDATE subexpressions. + */ + addNSItemToQuery(pstate, exclNSItem, false, true, true); + + /* + * Now transform the UPDATE subexpressions. + */ + onConflictSet = + transformUpdateTargetList(pstate, onConflictClause->targetList); + + onConflictWhere = transformWhereClause(pstate, + onConflictClause->whereClause, + EXPR_KIND_WHERE, "WHERE"); + + /* + * Remove the EXCLUDED pseudo relation from the query namespace, since + * it's not supposed to be available in RETURNING. (Maybe someday we + * could allow that, and drop this step.) + */ + Assert((ParseNamespaceItem *) llast(pstate->p_namespace) == exclNSItem); + pstate->p_namespace = list_delete_last(pstate->p_namespace); + } + + /* Finally, build ON CONFLICT DO [NOTHING | UPDATE] expression */ + result = makeNode(OnConflictExpr); + + result->action = onConflictClause->action; + result->arbiterElems = arbiterElems; + result->arbiterWhere = arbiterWhere; + result->constraint = arbiterConstraint; + result->onConflictSet = onConflictSet; + result->onConflictWhere = onConflictWhere; + result->exclRelIndex = exclRelIndex; + result->exclRelTlist = exclRelTlist; + + return result; +} + + +/* + * BuildOnConflictExcludedTargetlist + * Create target list for the EXCLUDED pseudo-relation of ON CONFLICT, + * representing the columns of targetrel with varno exclRelIndex. + * + * Note: Exported for use in the rewriter. + */ +List * +BuildOnConflictExcludedTargetlist(Relation targetrel, + Index exclRelIndex) +{ + List *result = NIL; + int attno; + Var *var; + TargetEntry *te; + + /* + * Note that resnos of the tlist must correspond to attnos of the + * underlying relation, hence we need entries for dropped columns too. + */ + for (attno = 0; attno < RelationGetNumberOfAttributes(targetrel); attno++) + { + Form_pg_attribute attr = TupleDescAttr(targetrel->rd_att, attno); + char *name; + + if (attr->attisdropped) + { + /* + * can't use atttypid here, but it doesn't really matter what type + * the Const claims to be. + */ + var = (Var *) makeNullConst(INT4OID, -1, InvalidOid); + name = NULL; + } + else + { + var = makeVar(exclRelIndex, attno + 1, + attr->atttypid, attr->atttypmod, + attr->attcollation, + 0); + name = pstrdup(NameStr(attr->attname)); + } + + te = makeTargetEntry((Expr *) var, + attno + 1, + name, + false); + + result = lappend(result, te); + } + + /* + * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like + * the other entries in the EXCLUDED tlist, its resno must match the Var's + * varattno, else the wrong things happen while resolving references in + * setrefs.c. This is against normal conventions for targetlists, but + * it's okay since we don't use this as a real tlist. + */ + var = makeVar(exclRelIndex, InvalidAttrNumber, + targetrel->rd_rel->reltype, + -1, InvalidOid, 0); + te = makeTargetEntry((Expr *) var, InvalidAttrNumber, NULL, true); + result = lappend(result, te); + + return result; +} + + +/* + * count_rowexpr_columns - + * get number of columns contained in a ROW() expression; + * return -1 if expression isn't a RowExpr or a Var referencing one. + * + * This is currently used only for hint purposes, so we aren't terribly + * tense about recognizing all possible cases. The Var case is interesting + * because that's what we'll get in the INSERT ... SELECT (...) case. + */ +static int +count_rowexpr_columns(ParseState *pstate, Node *expr) +{ + if (expr == NULL) + return -1; + if (IsA(expr, RowExpr)) + return list_length(((RowExpr *) expr)->args); + if (IsA(expr, Var)) + { + Var *var = (Var *) expr; + AttrNumber attnum = var->varattno; + + if (attnum > 0 && var->vartype == RECORDOID) + { + RangeTblEntry *rte; + + rte = GetRTEByRangeTablePosn(pstate, var->varno, var->varlevelsup); + if (rte->rtekind == RTE_SUBQUERY) + { + /* Subselect-in-FROM: examine sub-select's output expr */ + TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList, + attnum); + + if (ste == NULL || ste->resjunk) + return -1; + expr = (Node *) ste->expr; + if (IsA(expr, RowExpr)) + return list_length(((RowExpr *) expr)->args); + } + } + } + return -1; +} + + +/* + * transformSelectStmt - + * transforms a Select Statement + * + * Note: this covers only cases with no set operations and no VALUES lists; + * see below for the other cases. + */ +static Query * +transformSelectStmt(ParseState *pstate, SelectStmt *stmt) +{ + Query *qry = makeNode(Query); + Node *qual; + ListCell *l; + + qry->commandType = CMD_SELECT; + + /* process the WITH clause independently of all else */ + if (stmt->withClause) + { + qry->hasRecursive = stmt->withClause->recursive; + qry->cteList = transformWithClause(pstate, stmt->withClause); + qry->hasModifyingCTE = pstate->p_hasModifyingCTE; + } + + /* Complain if we get called from someplace where INTO is not allowed */ + if (stmt->intoClause) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("SELECT ... INTO is not allowed here"), + parser_errposition(pstate, + exprLocation((Node *) stmt->intoClause)))); + + /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */ + pstate->p_locking_clause = stmt->lockingClause; + + /* make WINDOW info available for window functions, too */ + pstate->p_windowdefs = stmt->windowClause; + + /* process the FROM clause */ + transformFromClause(pstate, stmt->fromClause); + + /* transform targetlist */ + qry->targetList = transformTargetList(pstate, stmt->targetList, + EXPR_KIND_SELECT_TARGET); + + /* mark column origins */ + markTargetListOrigins(pstate, qry->targetList); + + /* transform WHERE */ + qual = transformWhereClause(pstate, stmt->whereClause, + EXPR_KIND_WHERE, "WHERE"); + + /* initial processing of HAVING clause is much like WHERE clause */ + qry->havingQual = transformWhereClause(pstate, stmt->havingClause, + EXPR_KIND_HAVING, "HAVING"); + + /* + * Transform sorting/grouping stuff. Do ORDER BY first because both + * transformGroupClause and transformDistinctClause need the results. Note + * that these functions can also change the targetList, so it's passed to + * them by reference. + */ + qry->sortClause = transformSortClause(pstate, + stmt->sortClause, + &qry->targetList, + EXPR_KIND_ORDER_BY, + false /* allow SQL92 rules */ ); + + qry->groupClause = transformGroupClause(pstate, + stmt->groupClause, + &qry->groupingSets, + &qry->targetList, + qry->sortClause, + EXPR_KIND_GROUP_BY, + false /* allow SQL92 rules */ ); + qry->groupDistinct = stmt->groupDistinct; + + if (stmt->distinctClause == NIL) + { + qry->distinctClause = NIL; + qry->hasDistinctOn = false; + } + else if (linitial(stmt->distinctClause) == NULL) + { + /* We had SELECT DISTINCT */ + qry->distinctClause = transformDistinctClause(pstate, + &qry->targetList, + qry->sortClause, + false); + qry->hasDistinctOn = false; + } + else + { + /* We had SELECT DISTINCT ON */ + qry->distinctClause = transformDistinctOnClause(pstate, + stmt->distinctClause, + &qry->targetList, + qry->sortClause); + qry->hasDistinctOn = true; + } + + /* transform LIMIT */ + qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset, + EXPR_KIND_OFFSET, "OFFSET", + stmt->limitOption); + qry->limitCount = transformLimitClause(pstate, stmt->limitCount, + EXPR_KIND_LIMIT, "LIMIT", + stmt->limitOption); + qry->limitOption = stmt->limitOption; + + /* transform window clauses after we have seen all window functions */ + qry->windowClause = transformWindowDefinitions(pstate, + pstate->p_windowdefs, + &qry->targetList); + + /* resolve any still-unresolved output columns as being type text */ + if (pstate->p_resolve_unknowns) + resolveTargetListUnknowns(pstate, qry->targetList); + + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, qual); + + qry->hasSubLinks = pstate->p_hasSubLinks; + qry->hasWindowFuncs = pstate->p_hasWindowFuncs; + qry->hasTargetSRFs = pstate->p_hasTargetSRFs; + qry->hasAggs = pstate->p_hasAggs; + + foreach(l, stmt->lockingClause) + { + transformLockingClause(pstate, qry, + (LockingClause *) lfirst(l), false); + } + + assign_query_collations(pstate, qry); + + /* this must be done after collations, for reliable comparison of exprs */ + if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual) + parseCheckAggregates(pstate, qry); + + return qry; +} + +/* + * transformValuesClause - + * transforms a VALUES clause that's being used as a standalone SELECT + * + * We build a Query containing a VALUES RTE, rather as if one had written + * SELECT * FROM (VALUES ...) AS "*VALUES*" + */ +static Query * +transformValuesClause(ParseState *pstate, SelectStmt *stmt) +{ + Query *qry = makeNode(Query); + List *exprsLists = NIL; + List *coltypes = NIL; + List *coltypmods = NIL; + List *colcollations = NIL; + List **colexprs = NULL; + int sublist_length = -1; + bool lateral = false; + ParseNamespaceItem *nsitem; + ListCell *lc; + ListCell *lc2; + int i; + + qry->commandType = CMD_SELECT; + + /* Most SELECT stuff doesn't apply in a VALUES clause */ + Assert(stmt->distinctClause == NIL); + Assert(stmt->intoClause == NULL); + Assert(stmt->targetList == NIL); + Assert(stmt->fromClause == NIL); + Assert(stmt->whereClause == NULL); + Assert(stmt->groupClause == NIL); + Assert(stmt->havingClause == NULL); + Assert(stmt->windowClause == NIL); + Assert(stmt->op == SETOP_NONE); + + /* process the WITH clause independently of all else */ + if (stmt->withClause) + { + qry->hasRecursive = stmt->withClause->recursive; + qry->cteList = transformWithClause(pstate, stmt->withClause); + qry->hasModifyingCTE = pstate->p_hasModifyingCTE; + } + + /* + * For each row of VALUES, transform the raw expressions. + * + * Note that the intermediate representation we build is column-organized + * not row-organized. That simplifies the type and collation processing + * below. + */ + foreach(lc, stmt->valuesLists) + { + List *sublist = (List *) lfirst(lc); + + /* + * Do basic expression transformation (same as a ROW() expr, but here + * we disallow SetToDefault) + */ + sublist = transformExpressionList(pstate, sublist, + EXPR_KIND_VALUES, false); + + /* + * All the sublists must be the same length, *after* transformation + * (which might expand '*' into multiple items). The VALUES RTE can't + * handle anything different. + */ + if (sublist_length < 0) + { + /* Remember post-transformation length of first sublist */ + sublist_length = list_length(sublist); + /* and allocate array for per-column lists */ + colexprs = (List **) palloc0(sublist_length * sizeof(List *)); + } + else if (sublist_length != list_length(sublist)) + { + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("VALUES lists must all be the same length"), + parser_errposition(pstate, + exprLocation((Node *) sublist)))); + } + + /* Build per-column expression lists */ + i = 0; + foreach(lc2, sublist) + { + Node *col = (Node *) lfirst(lc2); + + colexprs[i] = lappend(colexprs[i], col); + i++; + } + + /* Release sub-list's cells to save memory */ + list_free(sublist); + + /* Prepare an exprsLists element for this row */ + exprsLists = lappend(exprsLists, NIL); + } + + /* + * Now resolve the common types of the columns, and coerce everything to + * those types. Then identify the common typmod and common collation, if + * any, of each column. + * + * We must do collation processing now because (1) assign_query_collations + * doesn't process rangetable entries, and (2) we need to label the VALUES + * RTE with column collations for use in the outer query. We don't + * consider conflict of implicit collations to be an error here; instead + * the column will just show InvalidOid as its collation, and you'll get a + * failure later if that results in failure to resolve a collation. + * + * Note we modify the per-column expression lists in-place. + */ + for (i = 0; i < sublist_length; i++) + { + Oid coltype; + int32 coltypmod; + Oid colcoll; + + coltype = select_common_type(pstate, colexprs[i], "VALUES", NULL); + + foreach(lc, colexprs[i]) + { + Node *col = (Node *) lfirst(lc); + + col = coerce_to_common_type(pstate, col, coltype, "VALUES"); + lfirst(lc) = (void *) col; + } + + coltypmod = select_common_typmod(pstate, colexprs[i], coltype); + colcoll = select_common_collation(pstate, colexprs[i], true); + + coltypes = lappend_oid(coltypes, coltype); + coltypmods = lappend_int(coltypmods, coltypmod); + colcollations = lappend_oid(colcollations, colcoll); + } + + /* + * Finally, rearrange the coerced expressions into row-organized lists. + */ + for (i = 0; i < sublist_length; i++) + { + forboth(lc, colexprs[i], lc2, exprsLists) + { + Node *col = (Node *) lfirst(lc); + List *sublist = lfirst(lc2); + + sublist = lappend(sublist, col); + lfirst(lc2) = sublist; + } + list_free(colexprs[i]); + } + + /* + * Ordinarily there can't be any current-level Vars in the expression + * lists, because the namespace was empty ... but if we're inside CREATE + * RULE, then NEW/OLD references might appear. In that case we have to + * mark the VALUES RTE as LATERAL. + */ + if (pstate->p_rtable != NIL && + contain_vars_of_level((Node *) exprsLists, 0)) + lateral = true; + + /* + * Generate the VALUES RTE + */ + nsitem = addRangeTableEntryForValues(pstate, exprsLists, + coltypes, coltypmods, colcollations, + NULL, lateral, true); + addNSItemToQuery(pstate, nsitem, true, true, true); + + /* + * Generate a targetlist as though expanding "*" + */ + Assert(pstate->p_next_resno == 1); + qry->targetList = expandNSItemAttrs(pstate, nsitem, 0, -1); + + /* + * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a + * VALUES, so cope. + */ + qry->sortClause = transformSortClause(pstate, + stmt->sortClause, + &qry->targetList, + EXPR_KIND_ORDER_BY, + false /* allow SQL92 rules */ ); + + qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset, + EXPR_KIND_OFFSET, "OFFSET", + stmt->limitOption); + qry->limitCount = transformLimitClause(pstate, stmt->limitCount, + EXPR_KIND_LIMIT, "LIMIT", + stmt->limitOption); + qry->limitOption = stmt->limitOption; + + if (stmt->lockingClause) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s cannot be applied to VALUES", + LCS_asString(((LockingClause *) + linitial(stmt->lockingClause))->strength)))); + + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, NULL); + + qry->hasSubLinks = pstate->p_hasSubLinks; + + assign_query_collations(pstate, qry); + + return qry; +} + +/* + * transformSetOperationStmt - + * transforms a set-operations tree + * + * A set-operation tree is just a SELECT, but with UNION/INTERSECT/EXCEPT + * structure to it. We must transform each leaf SELECT and build up a top- + * level Query that contains the leaf SELECTs as subqueries in its rangetable. + * The tree of set operations is converted into the setOperations field of + * the top-level Query. + */ +static Query * +transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) +{ + Query *qry = makeNode(Query); + SelectStmt *leftmostSelect; + int leftmostRTI; + Query *leftmostQuery; + SetOperationStmt *sostmt; + List *sortClause; + Node *limitOffset; + Node *limitCount; + List *lockingClause; + WithClause *withClause; + Node *node; + ListCell *left_tlist, + *lct, + *lcm, + *lcc, + *l; + List *targetvars, + *targetnames, + *sv_namespace; + int sv_rtable_length; + ParseNamespaceItem *jnsitem; + ParseNamespaceColumn *sortnscolumns; + int sortcolindex; + int tllen; + + qry->commandType = CMD_SELECT; + + /* + * Find leftmost leaf SelectStmt. We currently only need to do this in + * order to deliver a suitable error message if there's an INTO clause + * there, implying the set-op tree is in a context that doesn't allow + * INTO. (transformSetOperationTree would throw error anyway, but it + * seems worth the trouble to throw a different error for non-leftmost + * INTO, so we produce that error in transformSetOperationTree.) + */ + leftmostSelect = stmt->larg; + while (leftmostSelect && leftmostSelect->op != SETOP_NONE) + leftmostSelect = leftmostSelect->larg; + Assert(leftmostSelect && IsA(leftmostSelect, SelectStmt) && + leftmostSelect->larg == NULL); + if (leftmostSelect->intoClause) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("SELECT ... INTO is not allowed here"), + parser_errposition(pstate, + exprLocation((Node *) leftmostSelect->intoClause)))); + + /* + * We need to extract ORDER BY and other top-level clauses here and not + * let transformSetOperationTree() see them --- else it'll just recurse + * right back here! + */ + sortClause = stmt->sortClause; + limitOffset = stmt->limitOffset; + limitCount = stmt->limitCount; + lockingClause = stmt->lockingClause; + withClause = stmt->withClause; + + stmt->sortClause = NIL; + stmt->limitOffset = NULL; + stmt->limitCount = NULL; + stmt->lockingClause = NIL; + stmt->withClause = NULL; + + /* We don't support FOR UPDATE/SHARE with set ops at the moment. */ + if (lockingClause) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT", + LCS_asString(((LockingClause *) + linitial(lockingClause))->strength)))); + + /* Process the WITH clause independently of all else */ + if (withClause) + { + qry->hasRecursive = withClause->recursive; + qry->cteList = transformWithClause(pstate, withClause); + qry->hasModifyingCTE = pstate->p_hasModifyingCTE; + } + + /* + * Recursively transform the components of the tree. + */ + sostmt = castNode(SetOperationStmt, + transformSetOperationTree(pstate, stmt, true, NULL)); + Assert(sostmt); + qry->setOperations = (Node *) sostmt; + + /* + * Re-find leftmost SELECT (now it's a sub-query in rangetable) + */ + node = sostmt->larg; + while (node && IsA(node, SetOperationStmt)) + node = ((SetOperationStmt *) node)->larg; + Assert(node && IsA(node, RangeTblRef)); + leftmostRTI = ((RangeTblRef *) node)->rtindex; + leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery; + Assert(leftmostQuery != NULL); + + /* + * Generate dummy targetlist for outer query using column names of + * leftmost select and common datatypes/collations of topmost set + * operation. Also make lists of the dummy vars and their names for use + * in parsing ORDER BY. + * + * Note: we use leftmostRTI as the varno of the dummy variables. It + * shouldn't matter too much which RT index they have, as long as they + * have one that corresponds to a real RT entry; else funny things may + * happen when the tree is mashed by rule rewriting. + */ + qry->targetList = NIL; + targetvars = NIL; + targetnames = NIL; + sortnscolumns = (ParseNamespaceColumn *) + palloc0(list_length(sostmt->colTypes) * sizeof(ParseNamespaceColumn)); + sortcolindex = 0; + + forfour(lct, sostmt->colTypes, + lcm, sostmt->colTypmods, + lcc, sostmt->colCollations, + left_tlist, leftmostQuery->targetList) + { + Oid colType = lfirst_oid(lct); + int32 colTypmod = lfirst_int(lcm); + Oid colCollation = lfirst_oid(lcc); + TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist); + char *colName; + TargetEntry *tle; + Var *var; + + Assert(!lefttle->resjunk); + colName = pstrdup(lefttle->resname); + var = makeVar(leftmostRTI, + lefttle->resno, + colType, + colTypmod, + colCollation, + 0); + var->location = exprLocation((Node *) lefttle->expr); + tle = makeTargetEntry((Expr *) var, + (AttrNumber) pstate->p_next_resno++, + colName, + false); + qry->targetList = lappend(qry->targetList, tle); + targetvars = lappend(targetvars, var); + targetnames = lappend(targetnames, makeString(colName)); + sortnscolumns[sortcolindex].p_varno = leftmostRTI; + sortnscolumns[sortcolindex].p_varattno = lefttle->resno; + sortnscolumns[sortcolindex].p_vartype = colType; + sortnscolumns[sortcolindex].p_vartypmod = colTypmod; + sortnscolumns[sortcolindex].p_varcollid = colCollation; + sortnscolumns[sortcolindex].p_varnosyn = leftmostRTI; + sortnscolumns[sortcolindex].p_varattnosyn = lefttle->resno; + sortcolindex++; + } + + /* + * As a first step towards supporting sort clauses that are expressions + * using the output columns, generate a namespace entry that makes the + * output columns visible. A Join RTE node is handy for this, since we + * can easily control the Vars generated upon matches. + * + * Note: we don't yet do anything useful with such cases, but at least + * "ORDER BY upper(foo)" will draw the right error message rather than + * "foo not found". + */ + sv_rtable_length = list_length(pstate->p_rtable); + + jnsitem = addRangeTableEntryForJoin(pstate, + targetnames, + sortnscolumns, + JOIN_INNER, + 0, + targetvars, + NIL, + NIL, + NULL, + NULL, + false); + + sv_namespace = pstate->p_namespace; + pstate->p_namespace = NIL; + + /* add jnsitem to column namespace only */ + addNSItemToQuery(pstate, jnsitem, false, false, true); + + /* + * For now, we don't support resjunk sort clauses on the output of a + * setOperation tree --- you can only use the SQL92-spec options of + * selecting an output column by name or number. Enforce by checking that + * transformSortClause doesn't add any items to tlist. + */ + tllen = list_length(qry->targetList); + + qry->sortClause = transformSortClause(pstate, + sortClause, + &qry->targetList, + EXPR_KIND_ORDER_BY, + false /* allow SQL92 rules */ ); + + /* restore namespace, remove join RTE from rtable */ + pstate->p_namespace = sv_namespace; + pstate->p_rtable = list_truncate(pstate->p_rtable, sv_rtable_length); + + if (tllen != list_length(qry->targetList)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("invalid UNION/INTERSECT/EXCEPT ORDER BY clause"), + errdetail("Only result column names can be used, not expressions or functions."), + errhint("Add the expression/function to every SELECT, or move the UNION into a FROM clause."), + parser_errposition(pstate, + exprLocation(list_nth(qry->targetList, tllen))))); + + qry->limitOffset = transformLimitClause(pstate, limitOffset, + EXPR_KIND_OFFSET, "OFFSET", + stmt->limitOption); + qry->limitCount = transformLimitClause(pstate, limitCount, + EXPR_KIND_LIMIT, "LIMIT", + stmt->limitOption); + qry->limitOption = stmt->limitOption; + + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, NULL); + + qry->hasSubLinks = pstate->p_hasSubLinks; + qry->hasWindowFuncs = pstate->p_hasWindowFuncs; + qry->hasTargetSRFs = pstate->p_hasTargetSRFs; + qry->hasAggs = pstate->p_hasAggs; + + foreach(l, lockingClause) + { + transformLockingClause(pstate, qry, + (LockingClause *) lfirst(l), false); + } + + assign_query_collations(pstate, qry); + + /* this must be done after collations, for reliable comparison of exprs */ + if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual) + parseCheckAggregates(pstate, qry); + + return qry; +} + +/* + * Make a SortGroupClause node for a SetOperationStmt's groupClauses + * + * If require_hash is true, the caller is indicating that they need hash + * support or they will fail. So look extra hard for hash support. + */ +SortGroupClause * +makeSortGroupClauseForSetOp(Oid rescoltype, bool require_hash) +{ + SortGroupClause *grpcl = makeNode(SortGroupClause); + Oid sortop; + Oid eqop; + bool hashable; + + /* determine the eqop and optional sortop */ + get_sort_group_operators(rescoltype, + false, true, false, + &sortop, &eqop, NULL, + &hashable); + + /* + * The type cache doesn't believe that record is hashable (see + * cache_record_field_properties()), but if the caller really needs hash + * support, we can assume it does. Worst case, if any components of the + * record don't support hashing, we will fail at execution. + */ + if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID)) + hashable = true; + + /* we don't have a tlist yet, so can't assign sortgrouprefs */ + grpcl->tleSortGroupRef = 0; + grpcl->eqop = eqop; + grpcl->sortop = sortop; + grpcl->nulls_first = false; /* OK with or without sortop */ + grpcl->hashable = hashable; + + return grpcl; +} + +/* + * transformSetOperationTree + * Recursively transform leaves and internal nodes of a set-op tree + * + * In addition to returning the transformed node, if targetlist isn't NULL + * then we return a list of its non-resjunk TargetEntry nodes. For a leaf + * set-op node these are the actual targetlist entries; otherwise they are + * dummy entries created to carry the type, typmod, collation, and location + * (for error messages) of each output column of the set-op node. This info + * is needed only during the internal recursion of this function, so outside + * callers pass NULL for targetlist. Note: the reason for passing the + * actual targetlist entries of a leaf node is so that upper levels can + * replace UNKNOWN Consts with properly-coerced constants. + */ +static Node * +transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, + bool isTopLevel, List **targetlist) +{ + bool isLeaf; + + Assert(stmt && IsA(stmt, SelectStmt)); + + /* Guard against stack overflow due to overly complex set-expressions */ + check_stack_depth(); + + /* + * Validity-check both leaf and internal SELECTs for disallowed ops. + */ + if (stmt->intoClause) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT"), + parser_errposition(pstate, + exprLocation((Node *) stmt->intoClause)))); + + /* We don't support FOR UPDATE/SHARE with set ops at the moment. */ + if (stmt->lockingClause) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT", + LCS_asString(((LockingClause *) + linitial(stmt->lockingClause))->strength)))); + + /* + * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE, + * or WITH clauses attached, we need to treat it like a leaf node to + * generate an independent sub-Query tree. Otherwise, it can be + * represented by a SetOperationStmt node underneath the parent Query. + */ + if (stmt->op == SETOP_NONE) + { + Assert(stmt->larg == NULL && stmt->rarg == NULL); + isLeaf = true; + } + else + { + Assert(stmt->larg != NULL && stmt->rarg != NULL); + if (stmt->sortClause || stmt->limitOffset || stmt->limitCount || + stmt->lockingClause || stmt->withClause) + isLeaf = true; + else + isLeaf = false; + } + + if (isLeaf) + { + /* Process leaf SELECT */ + Query *selectQuery; + char selectName[32]; + ParseNamespaceItem *nsitem; + RangeTblRef *rtr; + ListCell *tl; + + /* + * Transform SelectStmt into a Query. + * + * This works the same as SELECT transformation normally would, except + * that we prevent resolving unknown-type outputs as TEXT. This does + * not change the subquery's semantics since if the column type + * matters semantically, it would have been resolved to something else + * anyway. Doing this lets us resolve such outputs using + * select_common_type(), below. + * + * Note: previously transformed sub-queries don't affect the parsing + * of this sub-query, because they are not in the toplevel pstate's + * namespace list. + */ + selectQuery = parse_sub_analyze((Node *) stmt, pstate, + NULL, false, false); + + /* + * Check for bogus references to Vars on the current query level (but + * upper-level references are okay). Normally this can't happen + * because the namespace will be empty, but it could happen if we are + * inside a rule. + */ + if (pstate->p_namespace) + { + if (contain_vars_of_level((Node *) selectQuery, 1)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_COLUMN_REFERENCE), + errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"), + parser_errposition(pstate, + locate_var_of_level((Node *) selectQuery, 1)))); + } + + /* + * Extract a list of the non-junk TLEs for upper-level processing. + */ + if (targetlist) + { + *targetlist = NIL; + foreach(tl, selectQuery->targetList) + { + TargetEntry *tle = (TargetEntry *) lfirst(tl); + + if (!tle->resjunk) + *targetlist = lappend(*targetlist, tle); + } + } + + /* + * Make the leaf query be a subquery in the top-level rangetable. + */ + snprintf(selectName, sizeof(selectName), "*SELECT* %d", + list_length(pstate->p_rtable) + 1); + nsitem = addRangeTableEntryForSubquery(pstate, + selectQuery, + makeAlias(selectName, NIL), + false, + false); + + /* + * Return a RangeTblRef to replace the SelectStmt in the set-op tree. + */ + rtr = makeNode(RangeTblRef); + rtr->rtindex = nsitem->p_rtindex; + return (Node *) rtr; + } + else + { + /* Process an internal node (set operation node) */ + SetOperationStmt *op = makeNode(SetOperationStmt); + List *ltargetlist; + List *rtargetlist; + ListCell *ltl; + ListCell *rtl; + const char *context; + bool recursive = (pstate->p_parent_cte && + pstate->p_parent_cte->cterecursive); + + context = (stmt->op == SETOP_UNION ? "UNION" : + (stmt->op == SETOP_INTERSECT ? "INTERSECT" : + "EXCEPT")); + + op->op = stmt->op; + op->all = stmt->all; + + /* + * Recursively transform the left child node. + */ + op->larg = transformSetOperationTree(pstate, stmt->larg, + false, + <argetlist); + + /* + * If we are processing a recursive union query, now is the time to + * examine the non-recursive term's output columns and mark the + * containing CTE as having those result columns. We should do this + * only at the topmost setop of the CTE, of course. + */ + if (isTopLevel && recursive) + determineRecursiveColTypes(pstate, op->larg, ltargetlist); + + /* + * Recursively transform the right child node. + */ + op->rarg = transformSetOperationTree(pstate, stmt->rarg, + false, + &rtargetlist); + + /* + * Verify that the two children have the same number of non-junk + * columns, and determine the types of the merged output columns. + */ + if (list_length(ltargetlist) != list_length(rtargetlist)) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("each %s query must have the same number of columns", + context), + parser_errposition(pstate, + exprLocation((Node *) rtargetlist)))); + + if (targetlist) + *targetlist = NIL; + op->colTypes = NIL; + op->colTypmods = NIL; + op->colCollations = NIL; + op->groupClauses = NIL; + forboth(ltl, ltargetlist, rtl, rtargetlist) + { + TargetEntry *ltle = (TargetEntry *) lfirst(ltl); + TargetEntry *rtle = (TargetEntry *) lfirst(rtl); + Node *lcolnode = (Node *) ltle->expr; + Node *rcolnode = (Node *) rtle->expr; + Oid lcoltype = exprType(lcolnode); + Oid rcoltype = exprType(rcolnode); + Node *bestexpr; + int bestlocation; + Oid rescoltype; + int32 rescoltypmod; + Oid rescolcoll; + + /* select common type, same as CASE et al */ + rescoltype = select_common_type(pstate, + list_make2(lcolnode, rcolnode), + context, + &bestexpr); + bestlocation = exprLocation(bestexpr); + + /* + * Verify the coercions are actually possible. If not, we'd fail + * later anyway, but we want to fail now while we have sufficient + * context to produce an error cursor position. + * + * For all non-UNKNOWN-type cases, we verify coercibility but we + * don't modify the child's expression, for fear of changing the + * child query's semantics. + * + * If a child expression is an UNKNOWN-type Const or Param, we + * want to replace it with the coerced expression. This can only + * happen when the child is a leaf set-op node. It's safe to + * replace the expression because if the child query's semantics + * depended on the type of this output column, it'd have already + * coerced the UNKNOWN to something else. We want to do this + * because (a) we want to verify that a Const is valid for the + * target type, or resolve the actual type of an UNKNOWN Param, + * and (b) we want to avoid unnecessary discrepancies between the + * output type of the child query and the resolved target type. + * Such a discrepancy would disable optimization in the planner. + * + * If it's some other UNKNOWN-type node, eg a Var, we do nothing + * (knowing that coerce_to_common_type would fail). The planner + * is sometimes able to fold an UNKNOWN Var to a constant before + * it has to coerce the type, so failing now would just break + * cases that might work. + */ + if (lcoltype != UNKNOWNOID) + lcolnode = coerce_to_common_type(pstate, lcolnode, + rescoltype, context); + else if (IsA(lcolnode, Const) || + IsA(lcolnode, Param)) + { + lcolnode = coerce_to_common_type(pstate, lcolnode, + rescoltype, context); + ltle->expr = (Expr *) lcolnode; + } + + if (rcoltype != UNKNOWNOID) + rcolnode = coerce_to_common_type(pstate, rcolnode, + rescoltype, context); + else if (IsA(rcolnode, Const) || + IsA(rcolnode, Param)) + { + rcolnode = coerce_to_common_type(pstate, rcolnode, + rescoltype, context); + rtle->expr = (Expr *) rcolnode; + } + + rescoltypmod = select_common_typmod(pstate, + list_make2(lcolnode, rcolnode), + rescoltype); + + /* + * Select common collation. A common collation is required for + * all set operators except UNION ALL; see SQL:2008 7.13 <query + * expression> Syntax Rule 15c. (If we fail to identify a common + * collation for a UNION ALL column, the colCollations element + * will be set to InvalidOid, which may result in a runtime error + * if something at a higher query level wants to use the column's + * collation.) + */ + rescolcoll = select_common_collation(pstate, + list_make2(lcolnode, rcolnode), + (op->op == SETOP_UNION && op->all)); + + /* emit results */ + op->colTypes = lappend_oid(op->colTypes, rescoltype); + op->colTypmods = lappend_int(op->colTypmods, rescoltypmod); + op->colCollations = lappend_oid(op->colCollations, rescolcoll); + + /* + * For all cases except UNION ALL, identify the grouping operators + * (and, if available, sorting operators) that will be used to + * eliminate duplicates. + */ + if (op->op != SETOP_UNION || !op->all) + { + ParseCallbackState pcbstate; + + setup_parser_errposition_callback(&pcbstate, pstate, + bestlocation); + + /* If it's a recursive union, we need to require hashing support. */ + op->groupClauses = lappend(op->groupClauses, + makeSortGroupClauseForSetOp(rescoltype, recursive)); + + cancel_parser_errposition_callback(&pcbstate); + } + + /* + * Construct a dummy tlist entry to return. We use a SetToDefault + * node for the expression, since it carries exactly the fields + * needed, but any other expression node type would do as well. + */ + if (targetlist) + { + SetToDefault *rescolnode = makeNode(SetToDefault); + TargetEntry *restle; + + rescolnode->typeId = rescoltype; + rescolnode->typeMod = rescoltypmod; + rescolnode->collation = rescolcoll; + rescolnode->location = bestlocation; + restle = makeTargetEntry((Expr *) rescolnode, + 0, /* no need to set resno */ + NULL, + false); + *targetlist = lappend(*targetlist, restle); + } + } + + return (Node *) op; + } +} + +/* + * Process the outputs of the non-recursive term of a recursive union + * to set up the parent CTE's columns + */ +static void +determineRecursiveColTypes(ParseState *pstate, Node *larg, List *nrtargetlist) +{ + Node *node; + int leftmostRTI; + Query *leftmostQuery; + List *targetList; + ListCell *left_tlist; + ListCell *nrtl; + int next_resno; + + /* + * Find leftmost leaf SELECT + */ + node = larg; + while (node && IsA(node, SetOperationStmt)) + node = ((SetOperationStmt *) node)->larg; + Assert(node && IsA(node, RangeTblRef)); + leftmostRTI = ((RangeTblRef *) node)->rtindex; + leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery; + Assert(leftmostQuery != NULL); + + /* + * Generate dummy targetlist using column names of leftmost select and + * dummy result expressions of the non-recursive term. + */ + targetList = NIL; + next_resno = 1; + + forboth(nrtl, nrtargetlist, left_tlist, leftmostQuery->targetList) + { + TargetEntry *nrtle = (TargetEntry *) lfirst(nrtl); + TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist); + char *colName; + TargetEntry *tle; + + Assert(!lefttle->resjunk); + colName = pstrdup(lefttle->resname); + tle = makeTargetEntry(nrtle->expr, + next_resno++, + colName, + false); + targetList = lappend(targetList, tle); + } + + /* Now build CTE's output column info using dummy targetlist */ + analyzeCTETargetList(pstate, pstate->p_parent_cte, targetList); +} + + +/* + * transformReturnStmt - + * transforms a return statement + */ +static Query * +transformReturnStmt(ParseState *pstate, ReturnStmt *stmt) +{ + Query *qry = makeNode(Query); + + qry->commandType = CMD_SELECT; + qry->isReturn = true; + + qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET), + 1, NULL, false)); + + if (pstate->p_resolve_unknowns) + resolveTargetListUnknowns(pstate, qry->targetList); + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, NULL); + qry->hasSubLinks = pstate->p_hasSubLinks; + qry->hasWindowFuncs = pstate->p_hasWindowFuncs; + qry->hasTargetSRFs = pstate->p_hasTargetSRFs; + qry->hasAggs = pstate->p_hasAggs; + + assign_query_collations(pstate, qry); + + return qry; +} + + +/* + * transformUpdateStmt - + * transforms an update statement + */ +static Query * +transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt) +{ + Query *qry = makeNode(Query); + ParseNamespaceItem *nsitem; + Node *qual; + + qry->commandType = CMD_UPDATE; + pstate->p_is_insert = false; + + /* process the WITH clause independently of all else */ + if (stmt->withClause) + { + qry->hasRecursive = stmt->withClause->recursive; + qry->cteList = transformWithClause(pstate, stmt->withClause); + qry->hasModifyingCTE = pstate->p_hasModifyingCTE; + } + + qry->resultRelation = setTargetTable(pstate, stmt->relation, + stmt->relation->inh, + true, + ACL_UPDATE); + nsitem = pstate->p_target_nsitem; + + /* subqueries in FROM cannot access the result relation */ + nsitem->p_lateral_only = true; + nsitem->p_lateral_ok = false; + + /* + * the FROM clause is non-standard SQL syntax. We used to be able to do + * this with REPLACE in POSTQUEL so we keep the feature. + */ + transformFromClause(pstate, stmt->fromClause); + + /* remaining clauses can reference the result relation normally */ + nsitem->p_lateral_only = false; + nsitem->p_lateral_ok = true; + + qual = transformWhereClause(pstate, stmt->whereClause, + EXPR_KIND_WHERE, "WHERE"); + + qry->returningList = transformReturningList(pstate, stmt->returningList); + + /* + * Now we are done with SELECT-like processing, and can get on with + * transforming the target list to match the UPDATE target columns. + */ + qry->targetList = transformUpdateTargetList(pstate, stmt->targetList); + + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, qual); + + qry->hasTargetSRFs = pstate->p_hasTargetSRFs; + qry->hasSubLinks = pstate->p_hasSubLinks; + + assign_query_collations(pstate, qry); + + return qry; +} + +/* + * transformUpdateTargetList - + * handle SET clause in UPDATE/INSERT ... ON CONFLICT UPDATE + */ +static List * +transformUpdateTargetList(ParseState *pstate, List *origTlist) +{ + List *tlist = NIL; + RangeTblEntry *target_rte; + ListCell *orig_tl; + ListCell *tl; + + tlist = transformTargetList(pstate, origTlist, + EXPR_KIND_UPDATE_SOURCE); + + /* Prepare to assign non-conflicting resnos to resjunk attributes */ + if (pstate->p_next_resno <= RelationGetNumberOfAttributes(pstate->p_target_relation)) + pstate->p_next_resno = RelationGetNumberOfAttributes(pstate->p_target_relation) + 1; + + /* Prepare non-junk columns for assignment to target table */ + target_rte = pstate->p_target_nsitem->p_rte; + orig_tl = list_head(origTlist); + + foreach(tl, tlist) + { + TargetEntry *tle = (TargetEntry *) lfirst(tl); + ResTarget *origTarget; + int attrno; + + if (tle->resjunk) + { + /* + * Resjunk nodes need no additional processing, but be sure they + * have resnos that do not match any target columns; else rewriter + * or planner might get confused. They don't need a resname + * either. + */ + tle->resno = (AttrNumber) pstate->p_next_resno++; + tle->resname = NULL; + continue; + } + if (orig_tl == NULL) + elog(ERROR, "UPDATE target count mismatch --- internal error"); + origTarget = lfirst_node(ResTarget, orig_tl); + + attrno = attnameAttNum(pstate->p_target_relation, + origTarget->name, true); + if (attrno == InvalidAttrNumber) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_COLUMN), + errmsg("column \"%s\" of relation \"%s\" does not exist", + origTarget->name, + RelationGetRelationName(pstate->p_target_relation)), + parser_errposition(pstate, origTarget->location))); + + updateTargetListEntry(pstate, tle, origTarget->name, + attrno, + origTarget->indirection, + origTarget->location); + + /* Mark the target column as requiring update permissions */ + target_rte->updatedCols = bms_add_member(target_rte->updatedCols, + attrno - FirstLowInvalidHeapAttributeNumber); + + orig_tl = lnext(origTlist, orig_tl); + } + if (orig_tl != NULL) + elog(ERROR, "UPDATE target count mismatch --- internal error"); + + return tlist; +} + +/* + * transformReturningList - + * handle a RETURNING clause in INSERT/UPDATE/DELETE + */ +static List * +transformReturningList(ParseState *pstate, List *returningList) +{ + List *rlist; + int save_next_resno; + + if (returningList == NIL) + return NIL; /* nothing to do */ + + /* + * We need to assign resnos starting at one in the RETURNING list. Save + * and restore the main tlist's value of p_next_resno, just in case + * someone looks at it later (probably won't happen). + */ + save_next_resno = pstate->p_next_resno; + pstate->p_next_resno = 1; + + /* transform RETURNING identically to a SELECT targetlist */ + rlist = transformTargetList(pstate, returningList, EXPR_KIND_RETURNING); + + /* + * Complain if the nonempty tlist expanded to nothing (which is possible + * if it contains only a star-expansion of a zero-column table). If we + * allow this, the parsed Query will look like it didn't have RETURNING, + * with results that would probably surprise the user. + */ + if (rlist == NIL) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("RETURNING must have at least one column"), + parser_errposition(pstate, + exprLocation(linitial(returningList))))); + + /* mark column origins */ + markTargetListOrigins(pstate, rlist); + + /* resolve any still-unresolved output columns as being type text */ + if (pstate->p_resolve_unknowns) + resolveTargetListUnknowns(pstate, rlist); + + /* restore state */ + pstate->p_next_resno = save_next_resno; + + return rlist; +} + + +/* + * transformPLAssignStmt - + * transform a PL/pgSQL assignment statement + * + * If there is no opt_indirection, the transformed statement looks like + * "SELECT a_expr ...", except the expression has been cast to the type of + * the target. With indirection, it's still a SELECT, but the expression will + * incorporate FieldStore and/or assignment SubscriptingRef nodes to compute a + * new value for a container-type variable represented by the target. The + * expression references the target as the container source. + */ +static Query * +transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt) +{ + Query *qry = makeNode(Query); + ColumnRef *cref = makeNode(ColumnRef); + List *indirection = stmt->indirection; + int nnames = stmt->nnames; + SelectStmt *sstmt = stmt->val; + Node *target; + Oid targettype; + int32 targettypmod; + Oid targetcollation; + List *tlist; + TargetEntry *tle; + Oid type_id; + Node *qual; + ListCell *l; + + /* + * First, construct a ColumnRef for the target variable. If the target + * has more than one dotted name, we have to pull the extra names out of + * the indirection list. + */ + cref->fields = list_make1(makeString(stmt->name)); + cref->location = stmt->location; + if (nnames > 1) + { + /* avoid munging the raw parsetree */ + indirection = list_copy(indirection); + while (--nnames > 0 && indirection != NIL) + { + Node *ind = (Node *) linitial(indirection); + + if (!IsA(ind, String)) + elog(ERROR, "invalid name count in PLAssignStmt"); + cref->fields = lappend(cref->fields, ind); + indirection = list_delete_first(indirection); + } + } + + /* + * Transform the target reference. Typically we will get back a Param + * node, but there's no reason to be too picky about its type. + */ + target = transformExpr(pstate, (Node *) cref, + EXPR_KIND_UPDATE_TARGET); + targettype = exprType(target); + targettypmod = exprTypmod(target); + targetcollation = exprCollation(target); + + /* + * The rest mostly matches transformSelectStmt, except that we needn't + * consider WITH or INTO, and we build a targetlist our own way. + */ + qry->commandType = CMD_SELECT; + pstate->p_is_insert = false; + + /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */ + pstate->p_locking_clause = sstmt->lockingClause; + + /* make WINDOW info available for window functions, too */ + pstate->p_windowdefs = sstmt->windowClause; + + /* process the FROM clause */ + transformFromClause(pstate, sstmt->fromClause); + + /* initially transform the targetlist as if in SELECT */ + tlist = transformTargetList(pstate, sstmt->targetList, + EXPR_KIND_SELECT_TARGET); + + /* we should have exactly one targetlist item */ + if (list_length(tlist) != 1) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg_plural("assignment source returned %d column", + "assignment source returned %d columns", + list_length(tlist), + list_length(tlist)))); + + tle = linitial_node(TargetEntry, tlist); + + /* + * This next bit is similar to transformAssignedExpr; the key difference + * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT. + */ + type_id = exprType((Node *) tle->expr); + + pstate->p_expr_kind = EXPR_KIND_UPDATE_TARGET; + + if (indirection) + { + tle->expr = (Expr *) + transformAssignmentIndirection(pstate, + target, + stmt->name, + false, + targettype, + targettypmod, + targetcollation, + indirection, + list_head(indirection), + (Node *) tle->expr, + COERCION_PLPGSQL, + exprLocation(target)); + } + else if (targettype != type_id && + (targettype == RECORDOID || ISCOMPLEX(targettype)) && + (type_id == RECORDOID || ISCOMPLEX(type_id))) + { + /* + * Hack: do not let coerce_to_target_type() deal with inconsistent + * composite types. Just pass the expression result through as-is, + * and let the PL/pgSQL executor do the conversion its way. This is + * rather bogus, but it's needed for backwards compatibility. + */ + } + else + { + /* + * For normal non-qualified target column, do type checking and + * coercion. + */ + Node *orig_expr = (Node *) tle->expr; + + tle->expr = (Expr *) + coerce_to_target_type(pstate, + orig_expr, type_id, + targettype, targettypmod, + COERCION_PLPGSQL, + COERCE_IMPLICIT_CAST, + -1); + /* With COERCION_PLPGSQL, this error is probably unreachable */ + if (tle->expr == NULL) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("variable \"%s\" is of type %s" + " but expression is of type %s", + stmt->name, + format_type_be(targettype), + format_type_be(type_id)), + errhint("You will need to rewrite or cast the expression."), + parser_errposition(pstate, exprLocation(orig_expr)))); + } + + pstate->p_expr_kind = EXPR_KIND_NONE; + + qry->targetList = list_make1(tle); + + /* transform WHERE */ + qual = transformWhereClause(pstate, sstmt->whereClause, + EXPR_KIND_WHERE, "WHERE"); + + /* initial processing of HAVING clause is much like WHERE clause */ + qry->havingQual = transformWhereClause(pstate, sstmt->havingClause, + EXPR_KIND_HAVING, "HAVING"); + + /* + * Transform sorting/grouping stuff. Do ORDER BY first because both + * transformGroupClause and transformDistinctClause need the results. Note + * that these functions can also change the targetList, so it's passed to + * them by reference. + */ + qry->sortClause = transformSortClause(pstate, + sstmt->sortClause, + &qry->targetList, + EXPR_KIND_ORDER_BY, + false /* allow SQL92 rules */ ); + + qry->groupClause = transformGroupClause(pstate, + sstmt->groupClause, + &qry->groupingSets, + &qry->targetList, + qry->sortClause, + EXPR_KIND_GROUP_BY, + false /* allow SQL92 rules */ ); + + if (sstmt->distinctClause == NIL) + { + qry->distinctClause = NIL; + qry->hasDistinctOn = false; + } + else if (linitial(sstmt->distinctClause) == NULL) + { + /* We had SELECT DISTINCT */ + qry->distinctClause = transformDistinctClause(pstate, + &qry->targetList, + qry->sortClause, + false); + qry->hasDistinctOn = false; + } + else + { + /* We had SELECT DISTINCT ON */ + qry->distinctClause = transformDistinctOnClause(pstate, + sstmt->distinctClause, + &qry->targetList, + qry->sortClause); + qry->hasDistinctOn = true; + } + + /* transform LIMIT */ + qry->limitOffset = transformLimitClause(pstate, sstmt->limitOffset, + EXPR_KIND_OFFSET, "OFFSET", + sstmt->limitOption); + qry->limitCount = transformLimitClause(pstate, sstmt->limitCount, + EXPR_KIND_LIMIT, "LIMIT", + sstmt->limitOption); + qry->limitOption = sstmt->limitOption; + + /* transform window clauses after we have seen all window functions */ + qry->windowClause = transformWindowDefinitions(pstate, + pstate->p_windowdefs, + &qry->targetList); + + qry->rtable = pstate->p_rtable; + qry->jointree = makeFromExpr(pstate->p_joinlist, qual); + + qry->hasSubLinks = pstate->p_hasSubLinks; + qry->hasWindowFuncs = pstate->p_hasWindowFuncs; + qry->hasTargetSRFs = pstate->p_hasTargetSRFs; + qry->hasAggs = pstate->p_hasAggs; + + foreach(l, sstmt->lockingClause) + { + transformLockingClause(pstate, qry, + (LockingClause *) lfirst(l), false); + } + + assign_query_collations(pstate, qry); + + /* this must be done after collations, for reliable comparison of exprs */ + if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual) + parseCheckAggregates(pstate, qry); + + return qry; +} + + +/* + * transformDeclareCursorStmt - + * transform a DECLARE CURSOR Statement + * + * DECLARE CURSOR is like other utility statements in that we emit it as a + * CMD_UTILITY Query node; however, we must first transform the contained + * query. We used to postpone that until execution, but it's really necessary + * to do it during the normal parse analysis phase to ensure that side effects + * of parser hooks happen at the expected time. + */ +static Query * +transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt) +{ + Query *result; + Query *query; + + if ((stmt->options & CURSOR_OPT_SCROLL) && + (stmt->options & CURSOR_OPT_NO_SCROLL)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_CURSOR_DEFINITION), + /* translator: %s is a SQL keyword */ + errmsg("cannot specify both %s and %s", + "SCROLL", "NO SCROLL"))); + + if ((stmt->options & CURSOR_OPT_ASENSITIVE) && + (stmt->options & CURSOR_OPT_INSENSITIVE)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_CURSOR_DEFINITION), + /* translator: %s is a SQL keyword */ + errmsg("cannot specify both %s and %s", + "ASENSITIVE", "INSENSITIVE"))); + + /* Transform contained query, not allowing SELECT INTO */ + query = transformStmt(pstate, stmt->query); + stmt->query = (Node *) query; + + /* Grammar should not have allowed anything but SELECT */ + if (!IsA(query, Query) || + query->commandType != CMD_SELECT) + elog(ERROR, "unexpected non-SELECT command in DECLARE CURSOR"); + + /* + * We also disallow data-modifying WITH in a cursor. (This could be + * allowed, but the semantics of when the updates occur might be + * surprising.) + */ + if (query->hasModifyingCTE) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("DECLARE CURSOR must not contain data-modifying statements in WITH"))); + + /* FOR UPDATE and WITH HOLD are not compatible */ + if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_HOLD)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("DECLARE CURSOR WITH HOLD ... %s is not supported", + LCS_asString(((RowMarkClause *) + linitial(query->rowMarks))->strength)), + errdetail("Holdable cursors must be READ ONLY."))); + + /* FOR UPDATE and SCROLL are not compatible */ + if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_SCROLL)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("DECLARE SCROLL CURSOR ... %s is not supported", + LCS_asString(((RowMarkClause *) + linitial(query->rowMarks))->strength)), + errdetail("Scrollable cursors must be READ ONLY."))); + + /* FOR UPDATE and INSENSITIVE are not compatible */ + if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_INSENSITIVE)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_CURSOR_DEFINITION), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("DECLARE INSENSITIVE CURSOR ... %s is not valid", + LCS_asString(((RowMarkClause *) + linitial(query->rowMarks))->strength)), + errdetail("Insensitive cursors must be READ ONLY."))); + + /* represent the command as a utility Query */ + result = makeNode(Query); + result->commandType = CMD_UTILITY; + result->utilityStmt = (Node *) stmt; + + return result; +} + + +/* + * transformExplainStmt - + * transform an EXPLAIN Statement + * + * EXPLAIN is like other utility statements in that we emit it as a + * CMD_UTILITY Query node; however, we must first transform the contained + * query. We used to postpone that until execution, but it's really necessary + * to do it during the normal parse analysis phase to ensure that side effects + * of parser hooks happen at the expected time. + */ +static Query * +transformExplainStmt(ParseState *pstate, ExplainStmt *stmt) +{ + Query *result; + + /* transform contained query, allowing SELECT INTO */ + stmt->query = (Node *) transformOptionalSelectInto(pstate, stmt->query); + + /* represent the command as a utility Query */ + result = makeNode(Query); + result->commandType = CMD_UTILITY; + result->utilityStmt = (Node *) stmt; + + return result; +} + + +/* + * transformCreateTableAsStmt - + * transform a CREATE TABLE AS, SELECT ... INTO, or CREATE MATERIALIZED VIEW + * Statement + * + * As with DECLARE CURSOR and EXPLAIN, transform the contained statement now. + */ +static Query * +transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt) +{ + Query *result; + Query *query; + + /* transform contained query, not allowing SELECT INTO */ + query = transformStmt(pstate, stmt->query); + stmt->query = (Node *) query; + + /* additional work needed for CREATE MATERIALIZED VIEW */ + if (stmt->objtype == OBJECT_MATVIEW) + { + /* + * Prohibit a data-modifying CTE in the query used to create a + * materialized view. It's not sufficiently clear what the user would + * want to happen if the MV is refreshed or incrementally maintained. + */ + if (query->hasModifyingCTE) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialized views must not use data-modifying statements in WITH"))); + + /* + * Check whether any temporary database objects are used in the + * creation query. It would be hard to refresh data or incrementally + * maintain it if a source disappeared. + */ + if (isQueryUsingTempRelation(query)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialized views must not use temporary tables or views"))); + + /* + * A materialized view would either need to save parameters for use in + * maintaining/loading the data or prohibit them entirely. The latter + * seems safer and more sane. + */ + if (query_contains_extern_params(query)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialized views may not be defined using bound parameters"))); + + /* + * For now, we disallow unlogged materialized views, because it seems + * like a bad idea for them to just go to empty after a crash. (If we + * could mark them as unpopulated, that would be better, but that + * requires catalog changes which crash recovery can't presently + * handle.) + */ + if (stmt->into->rel->relpersistence == RELPERSISTENCE_UNLOGGED) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialized views cannot be unlogged"))); + + /* + * At runtime, we'll need a copy of the parsed-but-not-rewritten Query + * for purposes of creating the view's ON SELECT rule. We stash that + * in the IntoClause because that's where intorel_startup() can + * conveniently get it from. + */ + stmt->into->viewQuery = (Node *) copyObject(query); + } + + /* represent the command as a utility Query */ + result = makeNode(Query); + result->commandType = CMD_UTILITY; + result->utilityStmt = (Node *) stmt; + + return result; +} + +/* + * transform a CallStmt + */ +static Query * +transformCallStmt(ParseState *pstate, CallStmt *stmt) +{ + List *targs; + ListCell *lc; + Node *node; + FuncExpr *fexpr; + HeapTuple proctup; + Datum proargmodes; + bool isNull; + List *outargs = NIL; + Query *result; + + /* + * First, do standard parse analysis on the procedure call and its + * arguments, allowing us to identify the called procedure. + */ + targs = NIL; + foreach(lc, stmt->funccall->args) + { + targs = lappend(targs, transformExpr(pstate, + (Node *) lfirst(lc), + EXPR_KIND_CALL_ARGUMENT)); + } + + node = ParseFuncOrColumn(pstate, + stmt->funccall->funcname, + targs, + pstate->p_last_srf, + stmt->funccall, + true, + stmt->funccall->location); + + assign_expr_collations(pstate, node); + + fexpr = castNode(FuncExpr, node); + + proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid)); + if (!HeapTupleIsValid(proctup)) + elog(ERROR, "cache lookup failed for function %u", fexpr->funcid); + + /* + * Expand the argument list to deal with named-argument notation and + * default arguments. For ordinary FuncExprs this'd be done during + * planning, but a CallStmt doesn't go through planning, and there seems + * no good reason not to do it here. + */ + fexpr->args = expand_function_arguments(fexpr->args, + true, + fexpr->funcresulttype, + proctup); + + /* Fetch proargmodes; if it's null, there are no output args */ + proargmodes = SysCacheGetAttr(PROCOID, proctup, + Anum_pg_proc_proargmodes, + &isNull); + if (!isNull) + { + /* + * Split the list into input arguments in fexpr->args and output + * arguments in stmt->outargs. INOUT arguments appear in both lists. + */ + ArrayType *arr; + int numargs; + char *argmodes; + List *inargs; + int i; + + arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */ + numargs = list_length(fexpr->args); + if (ARR_NDIM(arr) != 1 || + ARR_DIMS(arr)[0] != numargs || + ARR_HASNULL(arr) || + ARR_ELEMTYPE(arr) != CHAROID) + elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls", + numargs); + argmodes = (char *) ARR_DATA_PTR(arr); + + inargs = NIL; + i = 0; + foreach(lc, fexpr->args) + { + Node *n = lfirst(lc); + + switch (argmodes[i]) + { + case PROARGMODE_IN: + case PROARGMODE_VARIADIC: + inargs = lappend(inargs, n); + break; + case PROARGMODE_OUT: + outargs = lappend(outargs, n); + break; + case PROARGMODE_INOUT: + inargs = lappend(inargs, n); + outargs = lappend(outargs, copyObject(n)); + break; + default: + /* note we don't support PROARGMODE_TABLE */ + elog(ERROR, "invalid argmode %c for procedure", + argmodes[i]); + break; + } + i++; + } + fexpr->args = inargs; + } + + stmt->funcexpr = fexpr; + stmt->outargs = outargs; + + ReleaseSysCache(proctup); + + /* represent the command as a utility Query */ + result = makeNode(Query); + result->commandType = CMD_UTILITY; + result->utilityStmt = (Node *) stmt; + + return result; +} + +/* + * Produce a string representation of a LockClauseStrength value. + * This should only be applied to valid values (not LCS_NONE). + */ +const char * +LCS_asString(LockClauseStrength strength) +{ + switch (strength) + { + case LCS_NONE: + Assert(false); + break; + case LCS_FORKEYSHARE: + return "FOR KEY SHARE"; + case LCS_FORSHARE: + return "FOR SHARE"; + case LCS_FORNOKEYUPDATE: + return "FOR NO KEY UPDATE"; + case LCS_FORUPDATE: + return "FOR UPDATE"; + } + return "FOR some"; /* shouldn't happen */ +} + +/* + * Check for features that are not supported with FOR [KEY] UPDATE/SHARE. + * + * exported so planner can check again after rewriting, query pullup, etc + */ +void +CheckSelectLocking(Query *qry, LockClauseStrength strength) +{ + Assert(strength != LCS_NONE); /* else caller error */ + + if (qry->setOperations) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT", + LCS_asString(strength)))); + if (qry->distinctClause != NIL) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with DISTINCT clause", + LCS_asString(strength)))); + if (qry->groupClause != NIL || qry->groupingSets != NIL) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with GROUP BY clause", + LCS_asString(strength)))); + if (qry->havingQual != NULL) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with HAVING clause", + LCS_asString(strength)))); + if (qry->hasAggs) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with aggregate functions", + LCS_asString(strength)))); + if (qry->hasWindowFuncs) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with window functions", + LCS_asString(strength)))); + if (qry->hasTargetSRFs) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s is not allowed with set-returning functions in the target list", + LCS_asString(strength)))); +} + +/* + * Transform a FOR [KEY] UPDATE/SHARE clause + * + * This basically involves replacing names by integer relids. + * + * NB: if you need to change this, see also markQueryForLocking() + * in rewriteHandler.c, and isLockedRefname() in parse_relation.c. + */ +static void +transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc, + bool pushedDown) +{ + List *lockedRels = lc->lockedRels; + ListCell *l; + ListCell *rt; + Index i; + LockingClause *allrels; + + CheckSelectLocking(qry, lc->strength); + + /* make a clause we can pass down to subqueries to select all rels */ + allrels = makeNode(LockingClause); + allrels->lockedRels = NIL; /* indicates all rels */ + allrels->strength = lc->strength; + allrels->waitPolicy = lc->waitPolicy; + + if (lockedRels == NIL) + { + /* + * Lock all regular tables used in query and its subqueries. We + * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD + * in rules. This is a bit of an abuse of a mostly-obsolete flag, but + * it's convenient. We can't rely on the namespace mechanism that has + * largely replaced inFromCl, since for example we need to lock + * base-relation RTEs even if they are masked by upper joins. + */ + i = 0; + foreach(rt, qry->rtable) + { + RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt); + + ++i; + if (!rte->inFromCl) + continue; + switch (rte->rtekind) + { + case RTE_RELATION: + applyLockingClause(qry, i, lc->strength, lc->waitPolicy, + pushedDown); + rte->requiredPerms |= ACL_SELECT_FOR_UPDATE; + break; + case RTE_SUBQUERY: + applyLockingClause(qry, i, lc->strength, lc->waitPolicy, + pushedDown); + + /* + * FOR UPDATE/SHARE of subquery is propagated to all of + * subquery's rels, too. We could do this later (based on + * the marking of the subquery RTE) but it is convenient + * to have local knowledge in each query level about which + * rels need to be opened with RowShareLock. + */ + transformLockingClause(pstate, rte->subquery, + allrels, true); + break; + default: + /* ignore JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */ + break; + } + } + } + else + { + /* + * Lock just the named tables. As above, we allow locking any base + * relation regardless of alias-visibility rules, so we need to + * examine inFromCl to exclude OLD/NEW. + */ + foreach(l, lockedRels) + { + RangeVar *thisrel = (RangeVar *) lfirst(l); + + /* For simplicity we insist on unqualified alias names here */ + if (thisrel->catalogname || thisrel->schemaname) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s must specify unqualified relation names", + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + + i = 0; + foreach(rt, qry->rtable) + { + RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt); + char *rtename; + + ++i; + if (!rte->inFromCl) + continue; + + /* + * A join RTE without an alias is not visible as a relation + * name and needs to be skipped (otherwise it might hide a + * base relation with the same name), except if it has a USING + * alias, which *is* visible. + */ + if (rte->rtekind == RTE_JOIN && rte->alias == NULL) + { + if (rte->join_using_alias == NULL) + continue; + rtename = rte->join_using_alias->aliasname; + } + else + rtename = rte->eref->aliasname; + + if (strcmp(rtename, thisrel->relname) == 0) + { + switch (rte->rtekind) + { + case RTE_RELATION: + applyLockingClause(qry, i, lc->strength, + lc->waitPolicy, pushedDown); + rte->requiredPerms |= ACL_SELECT_FOR_UPDATE; + break; + case RTE_SUBQUERY: + applyLockingClause(qry, i, lc->strength, + lc->waitPolicy, pushedDown); + /* see comment above */ + transformLockingClause(pstate, rte->subquery, + allrels, true); + break; + case RTE_JOIN: + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s cannot be applied to a join", + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + break; + case RTE_FUNCTION: + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s cannot be applied to a function", + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + break; + case RTE_TABLEFUNC: + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s cannot be applied to a table function", + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + break; + case RTE_VALUES: + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s cannot be applied to VALUES", + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + break; + case RTE_CTE: + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s cannot be applied to a WITH query", + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + break; + case RTE_NAMEDTUPLESTORE: + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("%s cannot be applied to a named tuplestore", + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + break; + + /* Shouldn't be possible to see RTE_RESULT here */ + + default: + elog(ERROR, "unrecognized RTE type: %d", + (int) rte->rtekind); + break; + } + break; /* out of foreach loop */ + } + } + if (rt == NULL) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_TABLE), + /*------ + translator: %s is a SQL row locking clause such as FOR UPDATE */ + errmsg("relation \"%s\" in %s clause not found in FROM clause", + thisrel->relname, + LCS_asString(lc->strength)), + parser_errposition(pstate, thisrel->location))); + } + } +} + +/* + * Record locking info for a single rangetable item + */ +void +applyLockingClause(Query *qry, Index rtindex, + LockClauseStrength strength, LockWaitPolicy waitPolicy, + bool pushedDown) +{ + RowMarkClause *rc; + + Assert(strength != LCS_NONE); /* else caller error */ + + /* If it's an explicit clause, make sure hasForUpdate gets set */ + if (!pushedDown) + qry->hasForUpdate = true; + + /* Check for pre-existing entry for same rtindex */ + if ((rc = get_parse_rowmark(qry, rtindex)) != NULL) + { + /* + * If the same RTE is specified with more than one locking strength, + * use the strongest. (Reasonable, since you can't take both a shared + * and exclusive lock at the same time; it'll end up being exclusive + * anyway.) + * + * Similarly, if the same RTE is specified with more than one lock + * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in + * turn wins over waiting for the lock (the default). This is a bit + * more debatable but raising an error doesn't seem helpful. (Consider + * for instance SELECT FOR UPDATE NOWAIT from a view that internally + * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP + * LOCKED is reasonable since the former throws an error in case of + * coming across a locked tuple, which may be undesirable in some + * cases but it seems better than silently returning inconsistent + * results. + * + * And of course pushedDown becomes false if any clause is explicit. + */ + rc->strength = Max(rc->strength, strength); + rc->waitPolicy = Max(rc->waitPolicy, waitPolicy); + rc->pushedDown &= pushedDown; + return; + } + + /* Make a new RowMarkClause */ + rc = makeNode(RowMarkClause); + rc->rti = rtindex; + rc->strength = strength; + rc->waitPolicy = waitPolicy; + rc->pushedDown = pushedDown; + qry->rowMarks = lappend(qry->rowMarks, rc); +} + +/* + * Coverage testing for raw_expression_tree_walker(). + * + * When enabled, we run raw_expression_tree_walker() over every DML statement + * submitted to parse analysis. Without this provision, that function is only + * applied in limited cases involving CTEs, and we don't really want to have + * to test everything inside as well as outside a CTE. + */ +#ifdef RAW_EXPRESSION_COVERAGE_TEST + +static bool +test_raw_expression_coverage(Node *node, void *context) +{ + if (node == NULL) + return false; + return raw_expression_tree_walker(node, + test_raw_expression_coverage, + context); +} + +#endif /* RAW_EXPRESSION_COVERAGE_TEST */ |