diff options
| -rw-r--r-- | src/backend/parser/analyze.c | 37 | ||||
| -rw-r--r-- | src/backend/parser/parse_clause.c | 178 | ||||
| -rw-r--r-- | src/backend/parser/parse_relation.c | 38 | ||||
| -rw-r--r-- | src/backend/parser/parse_target.c | 40 | ||||
| -rw-r--r-- | src/include/parser/parse_node.h | 51 |
5 files changed, 200 insertions, 144 deletions
diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c index 1a112cd9a4e..93ef724ffff 100644 --- a/src/backend/parser/analyze.c +++ b/src/backend/parser/analyze.c @@ -401,8 +401,7 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt) List *exprList = NIL; bool isGeneralSelect; List *sub_rtable; - List *sub_relnamespace; - List *sub_varnamespace; + List *sub_namespace; List *icolumns; List *attrnos; RangeTblEntry *rte; @@ -454,16 +453,13 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt) { sub_rtable = pstate->p_rtable; pstate->p_rtable = NIL; - sub_relnamespace = pstate->p_relnamespace; - pstate->p_relnamespace = NIL; - sub_varnamespace = pstate->p_varnamespace; - pstate->p_varnamespace = NIL; + sub_namespace = pstate->p_namespace; + pstate->p_namespace = NIL; } else { sub_rtable = NIL; /* not used, but keep compiler quiet */ - sub_relnamespace = NIL; - sub_varnamespace = NIL; + sub_namespace = NIL; } /* @@ -513,8 +509,7 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt) */ sub_pstate->p_rtable = sub_rtable; sub_pstate->p_joinexprs = NIL; /* sub_rtable has no joins */ - sub_pstate->p_relnamespace = sub_relnamespace; - sub_pstate->p_varnamespace = sub_varnamespace; + sub_pstate->p_namespace = sub_namespace; selectQuery = transformStmt(sub_pstate, stmt->selectStmt); @@ -751,8 +746,7 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt) */ if (stmt->returningList) { - pstate->p_relnamespace = NIL; - pstate->p_varnamespace = NIL; + pstate->p_namespace = NIL; addRTEtoQuery(pstate, pstate->p_target_rangetblentry, false, true, true); qry->returningList = transformReturningList(pstate, @@ -1305,8 +1299,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) *l; List *targetvars, *targetnames, - *sv_relnamespace, - *sv_varnamespace; + *sv_namespace; int sv_rtable_length; RangeTblEntry *jrte; int tllen; @@ -1433,7 +1426,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) /* * As a first step towards supporting sort clauses that are expressions - * using the output columns, generate a varnamespace entry that makes the + * 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. * @@ -1450,12 +1443,10 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) NULL, false); - sv_relnamespace = pstate->p_relnamespace; - sv_varnamespace = pstate->p_varnamespace; - pstate->p_relnamespace = NIL; - pstate->p_varnamespace = NIL; + sv_namespace = pstate->p_namespace; + pstate->p_namespace = NIL; - /* add jrte to varnamespace only */ + /* add jrte to column namespace only */ addRTEtoQuery(pstate, jrte, false, false, true); /* @@ -1472,9 +1463,9 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) false /* no unknowns expected */ , false /* allow SQL92 rules */ ); + /* restore namespace, remove jrte from rtable */ + pstate->p_namespace = sv_namespace; pstate->p_rtable = list_truncate(pstate->p_rtable, sv_rtable_length); - pstate->p_relnamespace = sv_relnamespace; - pstate->p_varnamespace = sv_varnamespace; if (tllen != list_length(qry->targetList)) ereport(ERROR, @@ -1595,7 +1586,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, * because the namespace will be empty, but it could happen if we are * inside a rule. */ - if (pstate->p_relnamespace || pstate->p_varnamespace) + if (pstate->p_namespace) { if (contain_vars_of_level((Node *) selectQuery, 1)) ereport(ERROR, diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c index f9faa11b2e9..d354baf42fa 100644 --- a/src/backend/parser/parse_clause.c +++ b/src/backend/parser/parse_clause.c @@ -38,6 +38,9 @@ #include "utils/rel.h" +/* Convenience macro for the most common makeNamespaceItem() case */ +#define makeDefaultNSItem(rte) makeNamespaceItem(rte, true, true, false, true) + /* clause types for findTargetlistEntrySQL92 */ #define ORDER_CLAUSE 0 #define GROUP_CLAUSE 1 @@ -56,9 +59,7 @@ static Node *transformJoinUsingClause(ParseState *pstate, RangeTblEntry *leftRTE, RangeTblEntry *rightRTE, List *leftVars, List *rightVars); static Node *transformJoinOnClause(ParseState *pstate, JoinExpr *j, - RangeTblEntry *l_rte, - RangeTblEntry *r_rte, - List *relnamespace); + List *namespace); static RangeTblEntry *transformTableEntry(ParseState *pstate, RangeVar *r); static RangeTblEntry *transformCTEReference(ParseState *pstate, RangeVar *r, CommonTableExpr *cte, Index levelsup); @@ -68,11 +69,13 @@ static RangeTblEntry *transformRangeFunction(ParseState *pstate, RangeFunction *r); static Node *transformFromClauseItem(ParseState *pstate, Node *n, RangeTblEntry **top_rte, int *top_rti, - List **relnamespace); + List **namespace); static Node *buildMergedJoinVar(ParseState *pstate, JoinType jointype, Var *l_colvar, Var *r_colvar); static ParseNamespaceItem *makeNamespaceItem(RangeTblEntry *rte, + bool rel_visible, bool cols_visible, bool lateral_only, bool lateral_ok); +static void setNamespaceColumnVisibility(List *namespace, bool cols_visible); static void setNamespaceLateralState(List *namespace, bool lateral_only, bool lateral_ok); static void checkExprIsVarFree(ParseState *pstate, Node *n, @@ -97,10 +100,10 @@ static Node *transformFrameOffset(ParseState *pstate, int frameOptions, /* * transformFromClause - * Process the FROM clause and add items to the query's range table, - * joinlist, and namespaces. + * joinlist, and namespace. * - * Note: we assume that pstate's p_rtable, p_joinlist, p_relnamespace, and - * p_varnamespace lists were initialized to NIL when the pstate was created. + * Note: we assume that the pstate's p_rtable, p_joinlist, and p_namespace + * lists were initialized to NIL when the pstate was created. * We will add onto any entries already present --- this is needed for rule * processing, as well as for UPDATE and DELETE. */ @@ -113,7 +116,7 @@ transformFromClause(ParseState *pstate, List *frmList) * The grammar will have produced a list of RangeVars, RangeSubselects, * RangeFunctions, and/or JoinExprs. Transform each one (possibly adding * entries to the rtable), check for duplicate refnames, and then add it - * to the joinlist and namespaces. + * to the joinlist and namespace. * * Note we must process the items left-to-right for proper handling of * LATERAL references. @@ -123,22 +126,20 @@ transformFromClause(ParseState *pstate, List *frmList) Node *n = lfirst(fl); RangeTblEntry *rte; int rtindex; - List *relnamespace; + List *namespace; n = transformFromClauseItem(pstate, n, &rte, &rtindex, - &relnamespace); - /* Mark the new relnamespace items as visible to LATERAL */ - setNamespaceLateralState(relnamespace, true, true); + &namespace); + + checkNameSpaceConflicts(pstate, pstate->p_namespace, namespace); - checkNameSpaceConflicts(pstate, pstate->p_relnamespace, relnamespace); + /* Mark the new namespace items as visible only to LATERAL */ + setNamespaceLateralState(namespace, true, true); pstate->p_joinlist = lappend(pstate->p_joinlist, n); - pstate->p_relnamespace = list_concat(pstate->p_relnamespace, - relnamespace); - pstate->p_varnamespace = lappend(pstate->p_varnamespace, - makeNamespaceItem(rte, true, true)); + pstate->p_namespace = list_concat(pstate->p_namespace, namespace); } /* @@ -147,8 +148,7 @@ transformFromClause(ParseState *pstate, List *frmList) * for any namespace items that were already present when we were called; * but those should have been that way already. */ - setNamespaceLateralState(pstate->p_relnamespace, false, true); - setNamespaceLateralState(pstate->p_varnamespace, false, true); + setNamespaceLateralState(pstate->p_namespace, false, true); } /* @@ -217,7 +217,7 @@ setTargetTable(ParseState *pstate, RangeVar *relation, rte->requiredPerms = requiredPerms; /* - * If UPDATE/DELETE, add table to joinlist and namespaces. + * If UPDATE/DELETE, add table to joinlist and namespace. */ if (alsoSource) addRTEtoQuery(pstate, rte, true, true, true); @@ -383,14 +383,10 @@ transformJoinUsingClause(ParseState *pstate, * Result is a transformed qualification expression. */ static Node * -transformJoinOnClause(ParseState *pstate, JoinExpr *j, - RangeTblEntry *l_rte, - RangeTblEntry *r_rte, - List *relnamespace) +transformJoinOnClause(ParseState *pstate, JoinExpr *j, List *namespace) { Node *result; - List *save_relnamespace; - List *save_varnamespace; + List *save_namespace; /* * The namespace that the join expression should see is just the two @@ -400,19 +396,14 @@ transformJoinOnClause(ParseState *pstate, JoinExpr *j, * already did.) All namespace items are marked visible regardless of * LATERAL state. */ - save_relnamespace = pstate->p_relnamespace; - save_varnamespace = pstate->p_varnamespace; - - setNamespaceLateralState(relnamespace, false, true); - pstate->p_relnamespace = relnamespace; + setNamespaceLateralState(namespace, false, true); - pstate->p_varnamespace = list_make2(makeNamespaceItem(l_rte, false, true), - makeNamespaceItem(r_rte, false, true)); + save_namespace = pstate->p_namespace; + pstate->p_namespace = namespace; result = transformWhereClause(pstate, j->quals, "JOIN/ON"); - pstate->p_relnamespace = save_relnamespace; - pstate->p_varnamespace = save_varnamespace; + pstate->p_namespace = save_namespace; return result; } @@ -592,7 +583,8 @@ transformRangeFunction(ParseState *pstate, RangeFunction *r) * transformFromClauseItem - * Transform a FROM-clause item, adding any required entries to the * range table list being built in the ParseState, and return the - * transformed item ready to include in the joinlist and namespaces. + * transformed item ready to include in the joinlist. Also build a + * ParseNamespaceItem list describing the names exposed by this item. * This routine can recurse to handle SQL92 JOIN expressions. * * The function return value is the node to add to the jointree (a @@ -604,17 +596,14 @@ transformRangeFunction(ParseState *pstate, RangeFunction *r) * * *top_rti: receives the rangetable index of top_rte. (Ditto.) * - * *relnamespace: receives a List of ParseNamespaceItems for the RTEs exposed - * as relation names by this item. (The lateral_only flags in these items + * *namespace: receives a List of ParseNamespaceItems for the RTEs exposed + * as table/column names by this item. (The lateral_only flags in these items * are indeterminate and should be explicitly set by the caller before use.) - * - * We do not need to pass back an explicit varnamespace value, because - * in all cases the varnamespace contribution is exactly top_rte. */ static Node * transformFromClauseItem(ParseState *pstate, Node *n, RangeTblEntry **top_rte, int *top_rti, - List **relnamespace) + List **namespace) { if (IsA(n, RangeVar)) { @@ -644,7 +633,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, Assert(rte == rt_fetch(rtindex, pstate->p_rtable)); *top_rte = rte; *top_rti = rtindex; - *relnamespace = list_make1(makeNamespaceItem(rte, false, true)); + *namespace = list_make1(makeDefaultNSItem(rte)); rtr = makeNode(RangeTblRef); rtr->rtindex = rtindex; return (Node *) rtr; @@ -662,7 +651,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, Assert(rte == rt_fetch(rtindex, pstate->p_rtable)); *top_rte = rte; *top_rti = rtindex; - *relnamespace = list_make1(makeNamespaceItem(rte, false, true)); + *namespace = list_make1(makeDefaultNSItem(rte)); rtr = makeNode(RangeTblRef); rtr->rtindex = rtindex; return (Node *) rtr; @@ -680,7 +669,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, Assert(rte == rt_fetch(rtindex, pstate->p_rtable)); *top_rte = rte; *top_rti = rtindex; - *relnamespace = list_make1(makeNamespaceItem(rte, false, true)); + *namespace = list_make1(makeDefaultNSItem(rte)); rtr = makeNode(RangeTblRef); rtr->rtindex = rtindex; return (Node *) rtr; @@ -693,9 +682,9 @@ transformFromClauseItem(ParseState *pstate, Node *n, RangeTblEntry *r_rte; int l_rtindex; int r_rtindex; - List *l_relnamespace, - *r_relnamespace, - *my_relnamespace, + List *l_namespace, + *r_namespace, + *my_namespace, *l_colnames, *r_colnames, *res_colnames, @@ -703,8 +692,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, *r_colvars, *res_colvars; bool lateral_ok; - int sv_relnamespace_length, - sv_varnamespace_length; + int sv_namespace_length; RangeTblEntry *rte; int k; @@ -715,53 +703,49 @@ transformFromClauseItem(ParseState *pstate, Node *n, j->larg = transformFromClauseItem(pstate, j->larg, &l_rte, &l_rtindex, - &l_relnamespace); + &l_namespace); /* * Make the left-side RTEs available for LATERAL access within the * right side, by temporarily adding them to the pstate's namespace - * lists. Per SQL:2008, if the join type is not INNER or LEFT then + * list. Per SQL:2008, if the join type is not INNER or LEFT then * the left-side names must still be exposed, but it's an error to * reference them. (Stupid design, but that's what it says.) Hence, - * we always push them into the namespaces, but mark them as not + * we always push them into the namespace, but mark them as not * lateral_ok if the jointype is wrong. * * NB: this coding relies on the fact that list_concat is not * destructive to its second argument. */ lateral_ok = (j->jointype == JOIN_INNER || j->jointype == JOIN_LEFT); - setNamespaceLateralState(l_relnamespace, true, lateral_ok); - checkNameSpaceConflicts(pstate, pstate->p_relnamespace, l_relnamespace); - sv_relnamespace_length = list_length(pstate->p_relnamespace); - pstate->p_relnamespace = list_concat(pstate->p_relnamespace, - l_relnamespace); - sv_varnamespace_length = list_length(pstate->p_varnamespace); - pstate->p_varnamespace = lappend(pstate->p_varnamespace, - makeNamespaceItem(l_rte, true, lateral_ok)); + setNamespaceLateralState(l_namespace, true, lateral_ok); + + checkNameSpaceConflicts(pstate, pstate->p_namespace, l_namespace); + + sv_namespace_length = list_length(pstate->p_namespace); + pstate->p_namespace = list_concat(pstate->p_namespace, l_namespace); /* And now we can process the RHS */ j->rarg = transformFromClauseItem(pstate, j->rarg, &r_rte, &r_rtindex, - &r_relnamespace); + &r_namespace); - /* Remove the left-side RTEs from the namespace lists again */ - pstate->p_relnamespace = list_truncate(pstate->p_relnamespace, - sv_relnamespace_length); - pstate->p_varnamespace = list_truncate(pstate->p_varnamespace, - sv_varnamespace_length); + /* Remove the left-side RTEs from the namespace list again */ + pstate->p_namespace = list_truncate(pstate->p_namespace, + sv_namespace_length); /* * Check for conflicting refnames in left and right subtrees. Must do * this because higher levels will assume I hand back a self- * consistent namespace list. */ - checkNameSpaceConflicts(pstate, l_relnamespace, r_relnamespace); + checkNameSpaceConflicts(pstate, l_namespace, r_namespace); /* - * Generate combined relnamespace info for possible use below. + * Generate combined namespace info for possible use below. */ - my_relnamespace = list_concat(l_relnamespace, r_relnamespace); + my_namespace = list_concat(l_namespace, r_namespace); /* * Extract column name and var lists from both subtrees @@ -924,9 +908,7 @@ transformFromClauseItem(ParseState *pstate, Node *n, else if (j->quals) { /* User-written ON-condition; transform it */ - j->quals = transformJoinOnClause(pstate, j, - l_rte, r_rte, - my_relnamespace); + j->quals = transformJoinOnClause(pstate, j, my_namespace); } else { @@ -985,14 +967,30 @@ transformFromClauseItem(ParseState *pstate, Node *n, /* * Prepare returned namespace list. If the JOIN has an alias then it - * hides the contained RTEs as far as the relnamespace goes; - * otherwise, put the contained RTEs and *not* the JOIN into - * relnamespace. + * hides the contained RTEs completely; otherwise, the contained RTEs + * are still visible as table names, but are not visible for + * unqualified column-name access. + * + * Note: if there are nested alias-less JOINs, the lower-level ones + * will remain in the list although they have neither p_rel_visible + * nor p_cols_visible set. We could delete such list items, but it's + * unclear that it's worth expending cycles to do so. */ - if (j->alias) - *relnamespace = list_make1(makeNamespaceItem(rte, false, true)); + if (j->alias != NULL) + my_namespace = NIL; else - *relnamespace = my_relnamespace; + setNamespaceColumnVisibility(my_namespace, false); + + /* + * The join RTE itself is always made visible for unqualified column + * names. It's visible as a relation name only if it has an alias. + */ + *namespace = lappend(my_namespace, + makeNamespaceItem(rte, + (j->alias != NULL), + true, + false, + true)); return (Node *) j; } @@ -1125,18 +1123,38 @@ buildMergedJoinVar(ParseState *pstate, JoinType jointype, * Convenience subroutine to construct a ParseNamespaceItem. */ static ParseNamespaceItem * -makeNamespaceItem(RangeTblEntry *rte, bool lateral_only, bool lateral_ok) +makeNamespaceItem(RangeTblEntry *rte, bool rel_visible, bool cols_visible, + bool lateral_only, bool lateral_ok) { ParseNamespaceItem *nsitem; nsitem = (ParseNamespaceItem *) palloc(sizeof(ParseNamespaceItem)); nsitem->p_rte = rte; + nsitem->p_rel_visible = rel_visible; + nsitem->p_cols_visible = cols_visible; nsitem->p_lateral_only = lateral_only; nsitem->p_lateral_ok = lateral_ok; return nsitem; } /* + * setNamespaceColumnVisibility - + * Convenience subroutine to update cols_visible flags in a namespace list. + */ +static void +setNamespaceColumnVisibility(List *namespace, bool cols_visible) +{ + ListCell *lc; + + foreach(lc, namespace) + { + ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(lc); + + nsitem->p_cols_visible = cols_visible; + } +} + +/* * setNamespaceLateralState - * Convenience subroutine to update LATERAL flags in a namespace list. */ diff --git a/src/backend/parser/parse_relation.c b/src/backend/parser/parse_relation.c index 47686c8719c..98ebc400d50 100644 --- a/src/backend/parser/parse_relation.c +++ b/src/backend/parser/parse_relation.c @@ -135,11 +135,14 @@ scanNameSpaceForRefname(ParseState *pstate, const char *refname, int location) RangeTblEntry *result = NULL; ListCell *l; - foreach(l, pstate->p_relnamespace) + foreach(l, pstate->p_namespace) { ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l); RangeTblEntry *rte = nsitem->p_rte; + /* Ignore columns-only items */ + if (!nsitem->p_rel_visible) + continue; /* If not inside LATERAL, ignore lateral-only items */ if (nsitem->p_lateral_only && !pstate->p_lateral_active) continue; @@ -181,11 +184,14 @@ scanNameSpaceForRelid(ParseState *pstate, Oid relid, int location) RangeTblEntry *result = NULL; ListCell *l; - foreach(l, pstate->p_relnamespace) + foreach(l, pstate->p_namespace) { ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l); RangeTblEntry *rte = nsitem->p_rte; + /* Ignore columns-only items */ + if (!nsitem->p_rel_visible) + continue; /* If not inside LATERAL, ignore lateral-only items */ if (nsitem->p_lateral_only && !pstate->p_lateral_active) continue; @@ -277,7 +283,7 @@ isFutureCTE(ParseState *pstate, const char *refname) * * This is different from refnameRangeTblEntry in that it considers every * entry in the ParseState's rangetable(s), not only those that are currently - * visible in the p_relnamespace lists. This behavior is invalid per the SQL + * visible in the p_namespace list(s). This behavior is invalid per the SQL * spec, and it may give ambiguous results (there might be multiple equally * valid matches, but only one will be returned). This must be used ONLY * as a heuristic in giving suitable error messages. See errorMissingRTE. @@ -339,7 +345,7 @@ searchRangeTableForRel(ParseState *pstate, RangeVar *relation) } /* - * Check for relation-name conflicts between two relnamespace lists. + * Check for relation-name conflicts between two namespace lists. * Raise an error if any is found. * * Note: we assume that each given argument does not contain conflicts @@ -350,7 +356,8 @@ searchRangeTableForRel(ParseState *pstate, RangeVar *relation) * are for different relation OIDs (implying they are in different schemas). * * We ignore the lateral-only flags in the namespace items: the lists must - * not conflict, even when all items are considered visible. + * not conflict, even when all items are considered visible. However, + * columns-only items should be ignored. */ void checkNameSpaceConflicts(ParseState *pstate, List *namespace1, @@ -365,11 +372,16 @@ checkNameSpaceConflicts(ParseState *pstate, List *namespace1, const char *aliasname1 = rte1->eref->aliasname; ListCell *l2; + if (!nsitem1->p_rel_visible) + continue; + foreach(l2, namespace2) { ParseNamespaceItem *nsitem2 = (ParseNamespaceItem *) lfirst(l2); RangeTblEntry *rte2 = nsitem2->p_rte; + if (!nsitem2->p_rel_visible) + continue; if (strcmp(rte2->eref->aliasname, aliasname1) != 0) continue; /* definitely no conflict */ if (rte1->rtekind == RTE_RELATION && rte1->alias == NULL && @@ -573,12 +585,15 @@ colNameToVar(ParseState *pstate, char *colname, bool localonly, { ListCell *l; - foreach(l, pstate->p_varnamespace) + foreach(l, pstate->p_namespace) { ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l); RangeTblEntry *rte = nsitem->p_rte; Node *newresult; + /* Ignore table-only items */ + if (!nsitem->p_cols_visible) + continue; /* If not inside LATERAL, ignore lateral-only items */ if (nsitem->p_lateral_only && !pstate->p_lateral_active) continue; @@ -622,7 +637,7 @@ colNameToVar(ParseState *pstate, char *colname, bool localonly, * * This is different from colNameToVar in that it considers every entry in * the ParseState's rangetable(s), not only those that are currently visible - * in the p_varnamespace lists. This behavior is invalid per the SQL spec, + * in the p_namespace list(s). This behavior is invalid per the SQL spec, * and it may give ambiguous results (there might be multiple equally valid * matches, but only one will be returned). This must be used ONLY as a * heuristic in giving suitable error messages. See errorMissingColumn. @@ -1577,7 +1592,7 @@ isLockedRefname(ParseState *pstate, const char *refname) /* * Add the given RTE as a top-level entry in the pstate's join list - * and/or name space lists. (We assume caller has checked for any + * and/or namespace list. (We assume caller has checked for any * namespace conflicts.) The RTE is always marked as unconditionally * visible, that is, not LATERAL-only. */ @@ -1600,12 +1615,11 @@ addRTEtoQuery(ParseState *pstate, RangeTblEntry *rte, nsitem = (ParseNamespaceItem *) palloc(sizeof(ParseNamespaceItem)); nsitem->p_rte = rte; + nsitem->p_rel_visible = addToRelNameSpace; + nsitem->p_cols_visible = addToVarNameSpace; nsitem->p_lateral_only = false; nsitem->p_lateral_ok = true; - if (addToRelNameSpace) - pstate->p_relnamespace = lappend(pstate->p_relnamespace, nsitem); - if (addToVarNameSpace) - pstate->p_varnamespace = lappend(pstate->p_varnamespace, nsitem); + pstate->p_namespace = lappend(pstate->p_namespace, nsitem); } } diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c index 4d9e6e61066..ccd97fc845d 100644 --- a/src/backend/parser/parse_target.c +++ b/src/backend/parser/parse_target.c @@ -1108,9 +1108,10 @@ ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref, * ExpandAllTables() * Transforms '*' (in the target list) into a list of targetlist entries. * - * tlist entries are generated for each relation appearing in the query's - * varnamespace. We do not consider relnamespace because that would include - * input tables of aliasless JOINs, NEW/OLD pseudo-entries, etc. + * tlist entries are generated for each relation visible for unqualified + * column name access. We do not consider qualified-name-only entries because + * that would include input tables of aliasless JOINs, NEW/OLD pseudo-entries, + * etc. * * The referenced relations/columns are marked as requiring SELECT access. */ @@ -1118,29 +1119,42 @@ static List * ExpandAllTables(ParseState *pstate, int location) { List *target = NIL; + bool found_table = false; ListCell *l; - /* Check for SELECT *; */ - if (!pstate->p_varnamespace) - ereport(ERROR, - (errcode(ERRCODE_SYNTAX_ERROR), - errmsg("SELECT * with no tables specified is not valid"), - parser_errposition(pstate, location))); - - foreach(l, pstate->p_varnamespace) + foreach(l, pstate->p_namespace) { ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l); RangeTblEntry *rte = nsitem->p_rte; - int rtindex = RTERangeTablePosn(pstate, rte, NULL); + /* Ignore table-only items */ + if (!nsitem->p_cols_visible) + continue; /* Should not have any lateral-only items when parsing targetlist */ Assert(!nsitem->p_lateral_only); + /* Remember we found a p_cols_visible item */ + found_table = true; target = list_concat(target, - expandRelAttrs(pstate, rte, rtindex, 0, + expandRelAttrs(pstate, + rte, + RTERangeTablePosn(pstate, rte, + NULL), + 0, location)); } + /* + * Check for "SELECT *;". We do it this way, rather than checking for + * target == NIL, because we want to allow SELECT * FROM a zero_column + * table. + */ + if (!found_table) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("SELECT * with no tables specified is not valid"), + parser_errposition(pstate, location))); + return target; } diff --git a/src/include/parser/parse_node.h b/src/include/parser/parse_node.h index 13f745f6fa6..200b9744e51 100644 --- a/src/include/parser/parse_node.h +++ b/src/include/parser/parse_node.h @@ -54,25 +54,17 @@ typedef Node *(*CoerceParamHook) (ParseState *pstate, Param *param, * p_joinlist: list of join items (RangeTblRef and JoinExpr nodes) that * will become the fromlist of the query's top-level FromExpr node. * - * p_relnamespace: list of ParseNamespaceItems that represents the current - * namespace for table lookup, ie, those RTEs that are accessible by - * qualified names. (This may be just a subset of the whole rtable.) - * - * p_varnamespace: list of ParseNamespaceItems that represents the current - * namespace for column lookup, ie, those RTEs that are accessible by - * unqualified names. This is different from p_relnamespace because a JOIN - * without an alias does not hide the contained tables (so they must be in - * p_relnamespace) but it does hide their columns (unqualified references to - * the columns must refer to the JOIN, not the member tables). Other special - * RTEs such as NEW/OLD for rules may also appear in just one of these lists. + * p_namespace: list of ParseNamespaceItems that represents the current + * namespace for table and column lookup. (The RTEs listed here may be just + * a subset of the whole rtable. See ParseNamespaceItem comments below.) * * p_lateral_active: TRUE if we are currently parsing a LATERAL subexpression * of this parse level. This makes p_lateral_only namespace items visible, * whereas they are not visible when p_lateral_active is FALSE. * * p_ctenamespace: list of CommonTableExprs (WITH items) that are visible - * at the moment. This is entirely different from p_relnamespace because - * a CTE is not an RTE, rather "visibility" means you could make an RTE. + * at the moment. This is entirely different from p_namespace because a CTE + * is not an RTE, rather "visibility" means you could make an RTE from it. * * p_future_ctes: list of CommonTableExprs (WITH items) that are not yet * visible due to scope rules. This is used to help improve error messages. @@ -94,8 +86,8 @@ struct ParseState List *p_joinexprs; /* JoinExprs for RTE_JOIN p_rtable entries */ List *p_joinlist; /* join items so far (will become FromExpr * node's fromlist) */ - List *p_relnamespace; /* current namespace for relations */ - List *p_varnamespace; /* current namespace for columns */ + List *p_namespace; /* currently-referenceable RTEs (List of + * ParseNamespaceItem) */ bool p_lateral_active; /* p_lateral_only items visible? */ List *p_ctenamespace; /* current namespace for common table exprs */ List *p_future_ctes; /* common table exprs not yet in namespace */ @@ -125,10 +117,37 @@ struct ParseState void *p_ref_hook_state; /* common passthrough link for above */ }; -/* An element of p_relnamespace or p_varnamespace */ +/* + * An element of a namespace list. + * + * Namespace items with p_rel_visible set define which RTEs are accessible by + * qualified names, while those with p_cols_visible set define which RTEs are + * accessible by unqualified names. These sets are different because a JOIN + * without an alias does not hide the contained tables (so they must be + * visible for qualified references) but it does hide their columns + * (unqualified references to the columns refer to the JOIN, not the member + * tables, so we must not complain that such a reference is ambiguous). + * Various special RTEs such as NEW/OLD for rules may also appear with only + * one flag set. + * + * While processing the FROM clause, namespace items may appear with + * p_lateral_only set, meaning they are visible only to LATERAL + * subexpressions. (The pstate's p_lateral_active flag tells whether we are + * inside such a subexpression at the moment.) If p_lateral_ok is not set, + * it's an error to actually use such a namespace item. One might think it + * would be better to just exclude such items from visibility, but the wording + * of SQL:2008 requires us to do it this way. + * + * At no time should a namespace list contain two entries that conflict + * according to the rules in checkNameSpaceConflicts; but note that those + * are more complicated than "must have different alias names", so in practice + * code searching a namespace list has to check for ambiguous references. + */ typedef struct ParseNamespaceItem { RangeTblEntry *p_rte; /* The relation's rangetable entry */ + bool p_rel_visible; /* Relation name is visible? */ + bool p_cols_visible; /* Column names visible as unqualified refs? */ bool p_lateral_only; /* Is only visible to LATERAL expressions? */ bool p_lateral_ok; /* If so, does join type allow use? */ } ParseNamespaceItem; |