Loading...
Searching...
No Matches
parse_clause.c File Reference
#include "postgres.h"#include "access/htup_details.h"#include "access/nbtree.h"#include "access/table.h"#include "access/tsmapi.h"#include "catalog/catalog.h"#include "catalog/pg_am.h"#include "catalog/pg_amproc.h"#include "catalog/pg_constraint.h"#include "catalog/pg_type.h"#include "commands/defrem.h"#include "miscadmin.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "optimizer/optimizer.h"#include "parser/analyze.h"#include "parser/parse_clause.h"#include "parser/parse_coerce.h"#include "parser/parse_collate.h"#include "parser/parse_expr.h"#include "parser/parse_func.h"#include "parser/parse_oper.h"#include "parser/parse_relation.h"#include "parser/parse_target.h"#include "parser/parse_type.h"#include "parser/parser.h"#include "rewrite/rewriteManip.h"#include "utils/builtins.h"#include "utils/catcache.h"#include "utils/lsyscache.h"#include "utils/rel.h"#include "utils/syscache.h"
Include dependency graph for parse_clause.c:
Go to the source code of this file.
Function Documentation
◆ addTargetToGroupList()
|
static |
Definition at line 3605 of file parse_clause.c.
3607{
3609
3610 /* if tlist item is an UNKNOWN literal, change it to TEXT */
3612 {
3615 COERCION_IMPLICIT,
3616 COERCE_IMPLICIT_CAST,
3617 -1);
3619 }
3620
3621 /* avoid making duplicate grouplist entries */
3623 {
3625 Oid sortop;
3626 Oid eqop;
3627 bool hashable;
3629
3631
3632 /* determine the eqop and optional sortop */
3634 false, true, false,
3635 &sortop, &eqop, NULL,
3636 &hashable);
3637
3639
3641 grpcl->eqop = eqop;
3642 grpcl->sortop = sortop;
3644 * InvalidOid */
3646 grpcl->hashable = hashable;
3647
3649 }
3650
3652}
Index assignSortGroupRef(TargetEntry *tle, List *tlist)
Definition parse_clause.c:3662
bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList)
Definition parse_clause.c:3703
Node * coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition parse_coerce.c:158
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition parse_node.c:156
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition parse_node.c:140
void get_sort_group_operators(Oid argtype, bool needLT, bool needEQ, bool needGT, Oid *ltOpr, Oid *eqOpr, Oid *gtOpr, bool *isHashable)
Definition parse_oper.c:181
Definition primnodes.h:189
Definition nodes.h:135
Definition parse_node.h:343
Definition parsenodes.h:1494
References assignSortGroupRef(), cancel_parser_errposition_callback(), COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, exprType(), fb(), get_sort_group_operators(), InvalidOid, lappend(), makeNode, setup_parser_errposition_callback(), and targetIsInSortList().
Referenced by transformDistinctClause(), transformDistinctOnClause(), transformGroupClause(), and transformGroupClauseExpr().
◆ addTargetToSortList()
| List * addTargetToSortList | ( | ParseState * | pstate, |
| TargetEntry * | tle, | ||
| List * | sortlist, | ||
| List * | targetlist, | ||
| SortBy * | sortby | ||
| ) |
Definition at line 3461 of file parse_clause.c.
3463{
3465 Oid sortop;
3466 Oid eqop;
3467 bool hashable;
3468 bool reverse;
3469 int location;
3471
3472 /* if tlist item is an UNKNOWN literal, change it to TEXT */
3474 {
3477 COERCION_IMPLICIT,
3478 COERCE_IMPLICIT_CAST,
3479 -1);
3481 }
3482
3483 /*
3484 * Rather than clutter the API of get_sort_group_operators and the other
3485 * functions we're about to use, make use of error context callback to
3486 * mark any error reports with a parse position. We point to the operator
3487 * location if present, else to the expression being sorted. (NB: use the
3488 * original untransformed expression here; the TLE entry might well point
3489 * at a duplicate expression in the regular SELECT list.)
3490 */
3491 location = sortby->location;
3492 if (location < 0)
3495
3496 /* determine the sortop, eqop, and directionality */
3498 {
3502 true, true, false,
3503 &sortop, &eqop, NULL,
3504 &hashable);
3505 reverse = false;
3506 break;
3509 false, true, true,
3510 NULL, &eqop, &sortop,
3511 &hashable);
3512 reverse = true;
3513 break;
3517 restype,
3518 restype,
3519 false);
3520
3521 /*
3522 * Verify it's a valid ordering operator, fetch the corresponding
3523 * equality operator, and determine whether to consider it like
3524 * ASC or DESC.
3525 */
3526 eqop = get_equality_op_for_ordering_op(sortop, &reverse);
3533
3534 /*
3535 * Also see if the equality operator is hashable.
3536 */
3538 break;
3539 default:
3542 eqop = InvalidOid;
3543 hashable = false;
3544 reverse = false;
3545 break;
3546 }
3547
3549
3550 /* avoid making duplicate sortlist entries */
3552 {
3554
3556
3557 sortcl->eqop = eqop;
3558 sortcl->sortop = sortop;
3559 sortcl->hashable = hashable;
3560 sortcl->reverse_sort = reverse;
3561
3563 {
3565 /* NULLS FIRST is default for DESC; other way for ASC */
3566 sortcl->nulls_first = reverse;
3567 break;
3570 break;
3573 break;
3574 default:
3576 sortby->sortby_nulls);
3577 break;
3578 }
3579
3581 }
3582
3584}
Oid get_equality_op_for_ordering_op(Oid opno, bool *reverse)
Definition lsyscache.c:324
Oid compatible_oper_opid(List *op, Oid arg1, Oid arg2, bool noError)
Definition parse_oper.c:490
References Assert, assignSortGroupRef(), cancel_parser_errposition_callback(), COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, compatible_oper_opid(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, exprLocation(), exprType(), fb(), get_equality_op_for_ordering_op(), get_sort_group_operators(), InvalidOid, lappend(), llast, makeNode, NIL, OidIsValid, op_hashjoinable(), setup_parser_errposition_callback(), SORTBY_ASC, SORTBY_DEFAULT, SORTBY_DESC, SORTBY_NULLS_DEFAULT, SORTBY_NULLS_FIRST, SORTBY_NULLS_LAST, SORTBY_USING, strVal, and targetIsInSortList().
Referenced by transformAggregateCall(), and transformSortClause().
◆ assignSortGroupRef()
| Index assignSortGroupRef | ( | TargetEntry * | tle, |
| List * | tlist | ||
| ) |
Definition at line 3662 of file parse_clause.c.
3663{
3665 ListCell *l;
3666
3669
3670 /* easiest way to pick an unused refnumber: max used + 1 */
3671 maxRef = 0;
3672 foreach(l, tlist)
3673 {
3675
3678 }
3681}
Definition primnodes.h:2236
Definition pg_list.h:46
Referenced by addTargetToGroupList(), addTargetToSortList(), build_minmax_path(), create_unique_paths(), generate_setop_child_grouplist(), and transformDistinctOnClause().
◆ buildMergedJoinVar()
|
static |
Definition at line 1666 of file parse_clause.c.
1668{
1672 *r_node,
1673 *res_node;
1674
1677 "JOIN/USING",
1678 NULL);
1681 outcoltype);
1682
1683 /*
1684 * Insert coercion functions if needed. Note that a difference in typmod
1685 * can only happen if input has typmod but outcoltypmod is -1. In that
1686 * case we insert a RelabelType to clearly mark that result's typmod is
1687 * not same as input. We never need coerce_type_typmod.
1688 */
1697 COERCE_IMPLICIT_CAST);
1698 else
1700
1709 COERCE_IMPLICIT_CAST);
1710 else
1712
1713 /*
1714 * Choose what to emit
1715 */
1716 switch (jointype)
1717 {
1719
1720 /*
1721 * We can use either var; prefer non-coerced one if available.
1722 */
1727 else
1729 break;
1731 /* Always use left var */
1733 break;
1735 /* Always use right var */
1737 break;
1739 {
1740 /*
1741 * Here we must build a COALESCE expression to ensure that the
1742 * join output is non-null if either input is.
1743 */
1745
1747 /* coalescecollid will get set below */
1749 c->location = -1;
1751 break;
1752 }
1753 default:
1756 break;
1757 }
1758
1759 /*
1760 * Apply assign_expr_collations to fix up the collation info in the
1761 * coercion and CoalesceExpr nodes, if we made any. This must be done now
1762 * so that the join node's alias vars show correct collation info.
1763 */
1765
1767}
RelabelType * makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat)
Definition makefuncs.c:453
int32 select_common_typmod(ParseState *pstate, List *exprs, Oid common_type)
Definition parse_coerce.c:1645
Oid select_common_type(ParseState *pstate, List *exprs, const char *context, Node **which_expr)
Definition parse_coerce.c:1343
void assign_expr_collations(ParseState *pstate, Node *expr)
Definition parse_collate.c:177
Definition primnodes.h:1510
Definition primnodes.h:262
References assign_expr_collations(), COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, elog, ERROR, fb(), InvalidOid, IsA, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, list_make2, makeNode, makeRelabelType(), select_common_type(), and select_common_typmod().
Referenced by transformFromClauseItem().
◆ buildVarFromNSColumn()
|
static |
Definition at line 1639 of file parse_clause.c.
1640{
1641 Var *var;
1642
1645 nscol->p_varattno,
1646 nscol->p_vartype,
1647 nscol->p_vartypmod,
1648 nscol->p_varcollid,
1649 0);
1650 /* makeVar doesn't offer parameters for these, so set by hand: */
1652 var->varnosyn = nscol->p_varnosyn;
1653 var->varattnosyn = nscol->p_varattnosyn;
1654
1655 /* ... and update varnullingrels */
1656 markNullableIfNeeded(pstate, var);
1657
1658 return var;
1659}
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition makefuncs.c:66
void markNullableIfNeeded(ParseState *pstate, Var *var)
Definition parse_relation.c:1046
References Assert, fb(), makeVar(), markNullableIfNeeded(), and Var::varreturningtype.
Referenced by extractRemainingColumns(), and transformFromClauseItem().
◆ checkExprIsVarFree()
Definition at line 1925 of file parse_clause.c.
1926{
1928 {
1931 /* translator: %s is name of a SQL construct, eg LIMIT */
1933 constructName),
1934 parser_errposition(pstate,
1935 locate_var_of_level(n, 0))));
1936 }
1937}
int parser_errposition(ParseState *pstate, int location)
Definition parse_node.c:106
References contain_vars_of_level(), ereport, errcode(), errmsg(), ERROR, fb(), locate_var_of_level(), and parser_errposition().
Referenced by transformFrameOffset(), and transformLimitClause().
◆ checkTargetlistEntrySQL92()
|
static |
Definition at line 1950 of file parse_clause.c.
1952{
1954 {
1956 /* reject aggregates and window functions */
1961 /* translator: %s is name of a SQL construct, eg GROUP BY */
1964 parser_errposition(pstate,
1970 /* translator: %s is name of a SQL construct, eg GROUP BY */
1973 parser_errposition(pstate,
1975 break;
1977 /* no extra checks needed */
1978 break;
1980 /* no extra checks needed */
1981 break;
1982 default:
1984 break;
1985 }
1986}
bool contain_aggs_of_level(Node *node, int levelsup)
Definition rewriteManip.c:85
References contain_aggs_of_level(), contain_windowfuncs(), elog, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_DISTINCT_ON, EXPR_KIND_GROUP_BY, EXPR_KIND_ORDER_BY, fb(), locate_agg_of_level(), locate_windowfunc(), ParseState::p_hasAggs, ParseState::p_hasWindowFuncs, ParseExprKindName(), and parser_errposition().
Referenced by findTargetlistEntrySQL92().
◆ extractRemainingColumns()
|
static |
Definition at line 253 of file parse_clause.c.
259{
260 int colcount = 0;
264
265 /*
266 * While we could just test "list_member_int(*src_colnos, attnum)" to
267 * detect already-merged columns in the loop below, that would be O(N^2)
268 * for a wide input table. Instead build a bitmapset of just the merged
269 * USING columns, which we won't add to within the main loop.
270 */
273 {
275 }
276
277 attnum = 0;
279 {
281
282 attnum++;
283 /* Non-dropped and not already merged? */
285 {
286 /* Yes, so emit it as next output column */
290 buildVarFromNSColumn(pstate,
292 /* Copy the input relation's nscolumn data for this column */
294 colcount++;
295 }
296 }
297 return colcount;
298}
static Var * buildVarFromNSColumn(ParseState *pstate, ParseNamespaceColumn *nscol)
Definition parse_clause.c:1639
Definition bitmapset.h:50
References attnum, bms_add_member(), bms_is_member(), buildVarFromNSColumn(), fb(), lappend(), lappend_int(), lfirst, lfirst_int, and strVal.
Referenced by transformFromClauseItem().
◆ findTargetlistEntrySQL92()
|
static |
Definition at line 2006 of file parse_clause.c.
2008{
2010
2011 /*----------
2012 * Handle two special cases as mandated by the SQL92 spec:
2013 *
2014 * 1. Bare ColumnName (no qualifier or subscripts)
2015 * For a bare identifier, we search for a matching column name
2016 * in the existing target list. Multiple matches are an error
2017 * unless they refer to identical values; for example,
2018 * we allow SELECT a, a FROM table ORDER BY a
2019 * but not SELECT a AS b, b FROM table ORDER BY b
2020 * If no match is found, we fall through and treat the identifier
2021 * as an expression.
2022 * For GROUP BY, it is incorrect to match the grouping item against
2023 * targetlist entries: according to SQL92, an identifier in GROUP BY
2024 * is a reference to a column name exposed by FROM, not to a target
2025 * list column. However, many implementations (including pre-7.0
2026 * PostgreSQL) accept this anyway. So for GROUP BY, we look first
2027 * to see if the identifier matches any FROM column name, and only
2028 * try for a targetlist name if it doesn't. This ensures that we
2029 * adhere to the spec in the case where the name could be both.
2030 * DISTINCT ON isn't in the standard, so we can do what we like there;
2031 * we choose to make it work like ORDER BY, on the rather flimsy
2032 * grounds that ordinary DISTINCT works on targetlist entries.
2033 *
2034 * 2. IntegerConstant
2035 * This means to use the n'th item in the existing target list.
2036 * Note that it would make no sense to order/group/distinct by an
2037 * actual constant, so this does not create a conflict with SQL99.
2038 * GROUP BY column-number is not allowed by SQL92, but since
2039 * the standard has no other behavior defined for this syntax,
2040 * we may as well accept this common extension.
2041 *
2042 * Note that pre-existing resjunk targets must not be used in either case,
2043 * since the user didn't write them in his SELECT list.
2044 *
2045 * If neither special case applies, fall through to treat the item as
2046 * an expression per SQL99.
2047 *----------
2048 */
2052 {
2055
2057 {
2058 /*
2059 * In GROUP BY, we must prefer a match against a FROM-clause
2060 * column to one against the targetlist. Look to see if there is
2061 * a matching column. If so, fall through to use SQL99 rules.
2062 * NOTE: if name could refer ambiguously to more than one column
2063 * name exposed by FROM, colNameToVar will ereport(ERROR). That's
2064 * just what we want here.
2065 *
2066 * Small tweak for 7.4.3: ignore matches in upper query levels.
2067 * This effectively changes the search order for bare names to (1)
2068 * local FROM variables, (2) local targetlist aliases, (3) outer
2069 * FROM variables, whereas before it was (1) (3) (2). SQL92 and
2070 * SQL99 do not allow GROUPing BY an outer reference, so this
2071 * breaks no cases that are legal per spec, and it seems a more
2072 * self-consistent behavior.
2073 */
2076 }
2077
2079 {
2081
2083 {
2085
2088 {
2090 {
2094
2095 /*------
2096 translator: first %s is name of a SQL construct, eg ORDER BY */
2099 name),
2100 parser_errposition(pstate, location)));
2101 }
2102 else
2104 /* Stay in loop to check for ambiguity */
2105 }
2106 }
2108 {
2109 /* return the first match, after suitable validation */
2112 }
2113 }
2114 }
2116 {
2120
2124 /* translator: %s is name of a SQL construct, eg ORDER BY */
2128
2131 {
2133
2135 {
2137 {
2138 /* return the unique match, after suitable validation */
2141 }
2142 }
2143 }
2146 /* translator: %s is name of a SQL construct, eg ORDER BY */
2150 }
2151
2152 /*
2153 * Otherwise, we have an expression, so process it per SQL99 rules.
2154 */
2156}
static void checkTargetlistEntrySQL92(ParseState *pstate, TargetEntry *tle, ParseExprKind exprKind)
Definition parse_clause.c:1950
static TargetEntry * findTargetlistEntrySQL99(ParseState *pstate, Node *node, List **tlist, ParseExprKind exprKind)
Definition parse_clause.c:2172
Node * colNameToVar(ParseState *pstate, const char *colname, bool localonly, int location)
Definition parse_relation.c:894
Definition parsenodes.h:383
Definition parsenodes.h:309
Definition value.h:29
Definition value.h:64
References castNode, checkTargetlistEntrySQL92(), colNameToVar(), equal(), ereport, errcode(), errmsg(), ERROR, EXPR_KIND_GROUP_BY, fb(), findTargetlistEntrySQL99(), intVal, IsA, lfirst, linitial, list_length(), name, ParseExprKindName(), parser_errposition(), and strVal.
Referenced by transformDistinctOnClause(), transformGroupClauseExpr(), and transformSortClause().
◆ findTargetlistEntrySQL99()
|
static |
Definition at line 2172 of file parse_clause.c.
2174{
2177 Node *expr;
2178
2179 /*
2180 * Convert the untransformed node to a transformed expression, and search
2181 * for a match in the tlist. NOTE: it doesn't really matter whether there
2182 * is more than one match. Also, we are willing to match an existing
2183 * resjunk target here, though the SQL92 cases above must ignore resjunk
2184 * targets.
2185 */
2187
2189 {
2192
2193 /*
2194 * Ignore any implicit cast on the existing tlist expression.
2195 *
2196 * This essentially allows the ORDER/GROUP/etc item to adopt the same
2197 * datatype previously selected for a textually-equivalent tlist item.
2198 * There can't be any implicit cast at top level in an ordinary SELECT
2199 * tlist at this stage, but the case does arise with ORDER BY in an
2200 * aggregate function.
2201 */
2203
2206 }
2207
2208 /*
2209 * If no matches, construct a new target entry which is appended to the
2210 * end of the target list. This target is given resjunk = true so that it
2211 * will not be projected into the final tuple.
2212 */
2215
2217
2219}
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition parse_expr.c:120
TargetEntry * transformTargetEntry(ParseState *pstate, Node *node, Node *expr, ParseExprKind exprKind, char *colname, bool resjunk)
Definition parse_target.c:74
References equal(), fb(), lappend(), lfirst, strip_implicit_coercions(), transformExpr(), and transformTargetEntry().
Referenced by findTargetlistEntrySQL92(), transformGroupClauseExpr(), and transformSortClause().
◆ findWindowClause()
|
static |
Definition at line 3730 of file parse_clause.c.
3731{
3732 ListCell *l;
3733
3735 {
3737
3739 return wc;
3740 }
3741
3743}
Definition parsenodes.h:1595
References fb(), lfirst, and name.
Referenced by transformWindowDefinitions().
◆ flatten_grouping_sets()
Definition at line 2258 of file parse_clause.c.
2259{
2260 /* just in case of pathological input */
2261 check_stack_depth();
2262
2265
2267 {
2269 {
2271
2275 }
2276 break;
2278 {
2280 ListCell *l2;
2282
2285
2286 /*
2287 * at the top level, we skip over all empty grouping sets; the
2288 * caller can supply the canonical GROUP BY () if nothing is
2289 * left.
2290 */
2291
2294
2296 {
2299
2303 else
2305 }
2306
2307 /*
2308 * At top level, keep the grouping set node; but if we're in a
2309 * nested grouping set, then we need to concat the flattened
2310 * result into the outer list if it's simply nested.
2311 */
2312
2314 {
2316 }
2317 else
2319 }
2321 {
2323 ListCell *l;
2324
2326 {
2328
2330 {
2333 else
2334 result = lappend(result, n);
2335 }
2336 }
2337
2339 }
2340 default:
2341 break;
2342 }
2343
2344 return expr;
2345}
GroupingSet * makeGroupingSet(GroupingSetKind kind, List *content, int location)
Definition makefuncs.c:892
static Node * flatten_grouping_sets(Node *expr, bool toplevel, bool *hasGroupingSets)
Definition parse_clause.c:2258
Definition parsenodes.h:1565
Definition pg_list.h:54
Definition primnodes.h:1446
References RowExpr::args, check_stack_depth(), COERCE_IMPLICIT_CAST, fb(), flatten_grouping_sets(), GROUPING_SET_EMPTY, GROUPING_SET_SETS, IsA, lappend(), lfirst, list_concat(), makeGroupingSet(), NIL, and Node::type.
Referenced by flatten_grouping_sets(), and transformGroupClause().
◆ get_matching_location()
Definition at line 3239 of file parse_clause.c.
3240{
3243
3245 {
3248 }
3249 /* if no match, caller blew it */
3251 return -1; /* keep compiler quiet */
3252}
References elog, ERROR, exprLocation(), fb(), forboth, lfirst, and lfirst_int.
Referenced by transformDistinctOnClause().
◆ getNSItemForSpecialRelationTypes()
|
static |
Definition at line 1011 of file parse_clause.c.
1012{
1014 CommonTableExpr *cte;
1015 Index levelsup;
1016
1017 /*
1018 * if it is a qualified name, it can't be a CTE or tuplestore reference
1019 */
1022
1024 if (cte)
1028 else
1030
1032}
CommonTableExpr * scanNameSpaceForCTE(ParseState *pstate, const char *refname, Index *ctelevelsup)
Definition parse_relation.c:286
ParseNamespaceItem * addRangeTableEntryForENR(ParseState *pstate, RangeVar *rv, bool inFromCl)
Definition parse_relation.c:2480
bool scanNameSpaceForENR(ParseState *pstate, const char *refname)
Definition parse_relation.c:339
ParseNamespaceItem * addRangeTableEntryForCTE(ParseState *pstate, CommonTableExpr *cte, Index levelsup, RangeVar *rv, bool inFromCl)
Definition parse_relation.c:2328
Definition parsenodes.h:1727
Definition parse_node.h:293
References addRangeTableEntryForCTE(), addRangeTableEntryForENR(), fb(), RangeVar::relname, scanNameSpaceForCTE(), scanNameSpaceForENR(), and RangeVar::schemaname.
Referenced by transformFromClauseItem().
◆ markRelsAsNulledBy()
|
static |
Definition at line 1774 of file parse_clause.c.
1775{
1776 int varno;
1778
1779 /* Note: we can't see FromExpr here */
1781 {
1782 varno = ((RangeTblRef *) n)->rtindex;
1783 }
1785 {
1787
1788 /* recurse to children */
1791 varno = j->rtindex;
1792 }
1793 else
1794 {
1796 varno = 0; /* keep compiler quiet */
1797 }
1798
1799 /*
1800 * Now add jindex to the p_nullingrels set for relation varno. Since we
1801 * maintain the p_nullingrels list lazily, we might need to extend it to
1802 * make the varno'th entry exist.
1803 */
1808}
static void markRelsAsNulledBy(ParseState *pstate, Node *n, int jindex)
Definition parse_clause.c:1774
Definition primnodes.h:2327
Definition primnodes.h:2293
References bms_add_member(), elog, ERROR, fb(), IsA, j, lappend(), lfirst, list_length(), list_nth_cell(), markRelsAsNulledBy(), nodeTag, and ParseState::p_nullingrels.
Referenced by markRelsAsNulledBy(), and transformFromClauseItem().
◆ resolve_unique_index_expr()
|
static |
Definition at line 3264 of file parse_clause.c.
3266{
3268 ListCell *l;
3269
3271 {
3275
3276 /*
3277 * Raw grammar re-uses CREATE INDEX infrastructure for unique index
3278 * inference clause, and so will accept opclasses by name and so on.
3279 *
3280 * Make no attempt to match ASC or DESC ordering, NULLS FIRST/NULLS
3281 * LAST ordering or opclass options, since those are not significant
3282 * for inference purposes (any unique index matching the inference
3283 * specification in other regards is accepted indifferently). Actively
3284 * reject this as wrong-headed.
3285 */
3290 "ASC/DESC"),
3296 "NULLS FIRST/LAST"),
3303
3305 {
3306 /* Simple index attribute */
3307 ColumnRef *n;
3308
3309 /*
3310 * Grammar won't have built raw expression for us in event of
3311 * plain column reference. Create one directly, and perform
3312 * expression transformation. Planner expects this, and performs
3313 * its own normalization for the purposes of matching against
3314 * pg_index.
3315 */
3318 /* Location is approximately that of inference specification */
3321 }
3322 else
3323 {
3324 /* Do parse transformation of the raw expression */
3326 }
3327
3328 /*
3329 * transformExpr() will reject subqueries, aggregates, window
3330 * functions, and SRFs, based on being passed
3331 * EXPR_KIND_INDEX_EXPRESSION. So we needn't worry about those
3332 * further ... not that they would match any available index
3333 * expression anyway.
3334 */
3336
3337 /* Perform lookup of collation and operator class as required */
3340 else
3342 ielem->location);
3343
3346 else
3349
3351 }
3352
3353 return result;
3354}
Oid get_opclass_oid(Oid amID, List *opclassname, bool missing_ok)
Definition opclasscmds.c:220
Oid LookupCollation(ParseState *pstate, List *collnames, int location)
Definition parse_type.c:515
Definition parsenodes.h:809
Definition primnodes.h:2149
References ereport, errcode(), errmsg(), ERROR, EXPR_KIND_INDEX_EXPRESSION, fb(), ColumnRef::fields, get_opclass_oid(), InferClause::indexElems, InvalidOid, lappend(), lfirst, list_make1, ColumnRef::location, InferClause::location, LookupCollation(), makeNode, makeString(), NIL, parse(), parser_errposition(), SORTBY_DEFAULT, SORTBY_NULLS_DEFAULT, and transformExpr().
Referenced by transformOnConflictArbiter().
◆ setNamespaceColumnVisibility()
Definition at line 1815 of file parse_clause.c.
1816{
1818
1820 {
1822
1824 }
1825}
References fb(), lfirst, and ParseNamespaceItem::p_cols_visible.
Referenced by transformFromClauseItem().
◆ setNamespaceLateralState()
|
static |
Definition at line 1832 of file parse_clause.c.
1833{
1835
1837 {
1839
1842 }
1843}
References fb(), lfirst, and ParseNamespaceItem::p_lateral_only.
Referenced by transformFromClause(), transformFromClauseItem(), and transformJoinOnClause().
◆ setTargetTable()
| int setTargetTable | ( | ParseState * | pstate, |
| RangeVar * | relation, | ||
| bool | inh, | ||
| bool | alsoSource, | ||
| AclMode | requiredPerms | ||
| ) |
Definition at line 178 of file parse_clause.c.
180{
182
183 /*
184 * ENRs hide tables of the same name, so we need to check for them first.
185 * In contrast, CTEs don't hide tables (for this purpose).
186 */
192 relation->relname)));
193
194 /* Close old target; this could only happen for multi-action rules */
197
198 /*
199 * Open target rel and grab suitable lock (which we will hold till end of
200 * transaction).
201 *
202 * free_parsestate() will eventually do the corresponding table_close(),
203 * but *not* release the lock.
204 */
206 RowExclusiveLock);
207
208 /*
209 * Now build an RTE and a ParseNamespaceItem.
210 */
212 RowExclusiveLock,
214
215 /* remember the RTE/nsitem as being the query target */
217
218 /*
219 * Override addRangeTableEntry's default ACL_SELECT permissions check, and
220 * instead mark target table as requiring exactly the specified
221 * permissions.
222 *
223 * If we find an explicit reference to the rel later during parse
224 * analysis, we will add the ACL_SELECT bit back again; see
225 * markVarForSelectPriv and its callers.
226 */
228
229 /*
230 * If UPDATE/DELETE, add table to joinlist and namespace.
231 */
234
236}
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
Definition parse_relation.c:1580
Relation parserOpenTable(ParseState *pstate, const RangeVar *relation, int lockmode)
Definition parse_relation.c:1431
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
Definition parse_relation.c:2706
References addNSItemToQuery(), addRangeTableEntryForRelation(), RangeVar::alias, ereport, errcode(), errmsg(), ERROR, fb(), NoLock, ParseNamespaceItem::p_perminfo, ParseState::p_target_nsitem, ParseState::p_target_relation, parserOpenTable(), RangeVar::relname, RTEPermissionInfo::requiredPerms, RowExclusiveLock, scanNameSpaceForENR(), RangeVar::schemaname, and table_close().
Referenced by transformDeleteStmt(), transformInsertStmt(), transformMergeStmt(), and transformUpdateStmt().
◆ targetIsInSortList()
| bool targetIsInSortList | ( | TargetEntry * | tle, |
| Oid | sortop, | ||
| List * | sortList | ||
| ) |
Definition at line 3703 of file parse_clause.c.
3704{
3706 ListCell *l;
3707
3708 /* no need to scan list if tle has no marker */
3710 return false;
3711
3713 {
3715
3717 (sortop == InvalidOid ||
3718 sortop == scl->sortop ||
3720 return true;
3721 }
3722 return false;
3723}
References fb(), get_commutator(), InvalidOid, and lfirst.
Referenced by addTargetToGroupList(), addTargetToSortList(), check_output_expressions(), examine_simple_variable(), targetIsInAllPartitionLists(), transformDistinctOnClause(), and transformGroupClauseExpr().
◆ transformDistinctClause()
| List * transformDistinctClause | ( | ParseState * | pstate, |
| List ** | targetlist, | ||
| List * | sortClause, | ||
| bool | is_agg | ||
| ) |
Definition at line 3048 of file parse_clause.c.
3050{
3054
3055 /*
3056 * The distinctClause should consist of all ORDER BY items followed by all
3057 * other non-resjunk targetlist items. There must not be any resjunk
3058 * ORDER BY items --- that would imply that we are sorting by a value that
3059 * isn't necessarily unique within a DISTINCT group, so the results
3060 * wouldn't be well-defined. This construction ensures we follow the rule
3061 * that sortClause and distinctClause match; in fact the sortClause will
3062 * always be a prefix of distinctClause.
3063 *
3064 * Note a corner case: the same TLE could be in the ORDER BY list multiple
3065 * times with different sortops. We have to include it in the
3066 * distinctClause the same way to preserve the prefix property. The net
3067 * effect will be that the TLE value will be made unique according to both
3068 * sortops.
3069 */
3071 {
3074
3078 is_agg ?
3081 parser_errposition(pstate,
3084 }
3085
3086 /*
3087 * Now add any remaining non-resjunk tlist items, using default sort/group
3088 * semantics for their data types.
3089 */
3091 {
3093
3095 continue; /* ignore junk */
3097 result, *targetlist,
3099 }
3100
3101 /*
3102 * Complain if we found nothing to make DISTINCT. Returning an empty list
3103 * would cause the parsed Query to look like it didn't have DISTINCT, with
3104 * results that would probably surprise the user. Note: this case is
3105 * presently impossible for aggregates because of grammar restrictions,
3106 * but we check anyway.
3107 */
3111 is_agg ?
3114
3115 return result;
3116}
static List * addTargetToGroupList(ParseState *pstate, TargetEntry *tle, List *grouplist, List *targetlist, int location)
Definition parse_clause.c:3605
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition tlist.c:376
References addTargetToGroupList(), copyObject, ereport, errcode(), errmsg(), ERROR, exprLocation(), fb(), get_sortgroupclause_tle(), lappend(), lfirst, NIL, and parser_errposition().
Referenced by transformAggregateCall(), and transformSelectStmt().
◆ transformDistinctOnClause()
| List * transformDistinctOnClause | ( | ParseState * | pstate, |
| List * | distinctlist, | ||
| List ** | targetlist, | ||
| List * | sortClause | ||
| ) |
Definition at line 3132 of file parse_clause.c.
3134{
3140
3141 /*
3142 * Add all the DISTINCT ON expressions to the tlist (if not already
3143 * present, they are added as resjunk items). Assign sortgroupref numbers
3144 * to them, and make a list of these numbers. (NB: we rely below on the
3145 * sortgrouprefs list being one-for-one with the original distinctlist.
3146 * Also notice that we could have duplicate DISTINCT ON expressions and
3147 * hence duplicate entries in sortgrouprefs.)
3148 */
3150 {
3152 int sortgroupref;
3154
3156 EXPR_KIND_DISTINCT_ON);
3159 }
3160
3161 /*
3162 * If the user writes both DISTINCT ON and ORDER BY, adopt the sorting
3163 * semantics from ORDER BY items that match DISTINCT ON items, and also
3164 * adopt their column sort order. We insist that the distinctClause and
3165 * sortClause match, so throw error if we find the need to add any more
3166 * distinctClause items after we've skipped an ORDER BY item that wasn't
3167 * in DISTINCT ON.
3168 */
3171 {
3173
3175 {
3180 parser_errposition(pstate,
3182 sortgrouprefs,
3183 distinctlist))));
3184 else
3186 }
3187 else
3189 }
3190
3191 /*
3192 * Now add any remaining DISTINCT ON items, using default sort/group
3193 * semantics for their data types. (Note: this is pretty questionable; if
3194 * the ORDER BY list doesn't include all the DISTINCT ON items and more
3195 * besides, you certainly aren't using DISTINCT ON in the intended way,
3196 * and you probably aren't going to get consistent results. It might be
3197 * better to throw an error or warning here. But historically we've
3198 * allowed it, so keep doing so.)
3199 */
3201 {
3205
3207 continue; /* already in list (with some semantics) */
3214 result, *targetlist,
3216 }
3217
3218 /*
3219 * An empty result list is impossible here because of grammar
3220 * restrictions.
3221 */
3223
3224 return result;
3225}
static int get_matching_location(int sortgroupref, List *sortgrouprefs, List *exprs)
Definition parse_clause.c:3239
static TargetEntry * findTargetlistEntrySQL92(ParseState *pstate, Node *node, List **tlist, ParseExprKind exprKind)
Definition parse_clause.c:2006
TargetEntry * get_sortgroupref_tle(Index sortref, List *targetList)
Definition tlist.c:354
References addTargetToGroupList(), Assert, assignSortGroupRef(), copyObject, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_DISTINCT_ON, exprLocation(), fb(), findTargetlistEntrySQL92(), forboth, get_matching_location(), get_sortgroupref_tle(), InvalidOid, lappend(), lappend_int(), lfirst, lfirst_int, list_member_int(), NIL, parser_errposition(), and targetIsInSortList().
Referenced by transformSelectStmt().
◆ transformFrameOffset()
|
static |
Definition at line 3757 of file parse_clause.c.
3760{
3762 Node *node;
3763
3765
3766 /* Quick exit if no offset expression */
3769
3771 {
3772 /* Transform the raw expression tree */
3774
3775 /*
3776 * Like LIMIT clause, simply coerce to int8
3777 */
3780 }
3782 {
3783 /*
3784 * We must look up the in_range support function that's to be used,
3785 * possibly choosing one of several, and coerce the "offset" value to
3786 * the appropriate input type.
3787 */
3790 int nfuncs = 0;
3791 int nmatches = 0;
3796
3797 /* Transform the raw expression tree */
3800
3801 /*
3802 * If there are multiple candidates, we'll prefer the one that exactly
3803 * matches nodeType; or if nodeType is as yet unknown, prefer the one
3804 * that exactly matches the sort column type. (The second rule is
3805 * like what we do for "known_type operator unknown".)
3806 */
3808
3809 /* Find the in_range support functions applicable to this case */
3814 {
3817
3818 /* The search will find all support proc types; ignore others */
3820 continue;
3821 nfuncs++;
3822
3823 /* Ignore function if given value can't be coerced to that type */
3825 COERCION_IMPLICIT))
3826 continue;
3827 nmatches++;
3828
3829 /* Remember preferred match, or any match if didn't find that */
3831 {
3834 }
3835 }
3837
3838 /*
3839 * Throw error if needed. It seems worth taking the trouble to
3840 * distinguish "no support at all" from "you didn't match any
3841 * available offset type".
3842 */
3843 if (nfuncs == 0)
3849 if (nmatches == 0)
3852 errmsg("RANGE with offset PRECEDING/FOLLOWING is not supported for column type %s and offset type %s",
3860 errmsg("RANGE with offset PRECEDING/FOLLOWING has multiple interpretations for column type %s and offset type %s",
3865
3866 /* OK, coerce the offset to the right type */
3868 node = coerce_to_specific_type(pstate, node,
3871 }
3873 {
3874 /* Transform the raw expression tree */
3876
3877 /*
3878 * Like LIMIT clause, simply coerce to int8
3879 */
3882 }
3883 else
3884 {
3886 node = NULL;
3887 }
3888
3889 /* Disallow variables in frame offsets */
3891
3892 return node;
3893}
static void checkExprIsVarFree(ParseState *pstate, Node *n, const char *constructName)
Definition parse_clause.c:1925
Node * coerce_to_specific_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *constructName)
Definition parse_coerce.c:1256
bool can_coerce_type(int nargs, const Oid *input_typeids, const Oid *target_typeids, CoercionContext ccontext)
Definition parse_coerce.c:558
Definition htup.h:63
Definition catcache.h:158
References Assert, BTINRANGE_PROC, can_coerce_type(), checkExprIsVarFree(), coerce_to_specific_type(), COERCION_IMPLICIT, ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_WINDOW_FRAME_GROUPS, EXPR_KIND_WINDOW_FRAME_RANGE, EXPR_KIND_WINDOW_FRAME_ROWS, exprLocation(), exprType(), fb(), format_type_be(), FRAMEOPTION_GROUPS, FRAMEOPTION_RANGE, FRAMEOPTION_ROWS, GETSTRUCT(), i, InvalidOid, ObjectIdGetDatum(), parser_errposition(), ReleaseCatCacheList(), SearchSysCacheList2, and transformExpr().
Referenced by transformWindowDefinitions().
◆ transformFromClause()
| void transformFromClause | ( | ParseState * | pstate, |
| List * | frmList | ||
| ) |
Definition at line 112 of file parse_clause.c.
113{
115
116 /*
117 * The grammar will have produced a list of RangeVars, RangeSubselects,
118 * RangeFunctions, and/or JoinExprs. Transform each one (possibly adding
119 * entries to the rtable), check for duplicate refnames, and then add it
120 * to the joinlist and namespace.
121 *
122 * Note we must process the items left-to-right for proper handling of
123 * LATERAL references.
124 */
126 {
130
131 n = transformFromClauseItem(pstate, n,
132 &nsitem,
133 &namespace);
134
136
137 /* Mark the new namespace items as visible only to LATERAL */
139
142 }
143
144 /*
145 * We're done parsing the FROM list, so make all namespace items
146 * unconditionally visible. Note that this will also reset lateral_only
147 * for any namespace items that were already present when we were called;
148 * but those should have been that way already.
149 */
151}
static void setNamespaceLateralState(List *namespace, bool lateral_only, bool lateral_ok)
Definition parse_clause.c:1832
static Node * transformFromClauseItem(ParseState *pstate, Node *n, ParseNamespaceItem **top_nsitem, List **namespace)
Definition parse_clause.c:1054
void checkNameSpaceConflicts(ParseState *pstate, List *namespace1, List *namespace2)
Definition parse_relation.c:438
References checkNameSpaceConflicts(), fb(), lappend(), lfirst, list_concat(), ParseState::p_joinlist, ParseState::p_namespace, setNamespaceLateralState(), and transformFromClauseItem().
Referenced by transformDeleteStmt(), transformMergeStmt(), transformSelectStmt(), and transformUpdateStmt().
◆ transformFromClauseItem()
|
static |
Definition at line 1054 of file parse_clause.c.
1057{
1058 /* Guard against stack overflow due to overly deep subtree */
1059 check_stack_depth();
1060
1062 {
1063 /* Plain relation reference, or perhaps a CTE reference */
1067
1068 /* Check if it's a CTE or tuplestore reference */
1070
1071 /* if not found above, must be a table reference */
1074
1080 }
1082 {
1083 /* sub-SELECT is like a plain relation */
1086
1093 }
1095 {
1096 /* function is like a plain relation */
1099
1106 }
1108 {
1109 /* table function is like a plain relation */
1112
1115 else
1117
1123 }
1125 {
1126 /* TABLESAMPLE clause (wrapping some other valid FROM node) */
1128 Node *rel;
1130
1131 /* Recursively transform the contained relation */
1134 rte = (*top_nsitem)->p_rte;
1135 /* We only support this on plain relations and matviews */
1144
1145 /* Transform TABLESAMPLE details and attach to the RTE */
1147 return rel;
1148 }
1150 {
1151 /* A newfangled join expression */
1157 *r_namespace,
1158 *my_namespace,
1159 *l_colnames,
1160 *r_colnames,
1161 *res_colnames,
1162 *l_colnos,
1163 *r_colnos,
1164 *res_colvars;
1166 *r_nscolumns,
1167 *res_nscolumns;
1171 int k;
1172
1173 /*
1174 * Recursively process the left subtree, then the right. We must do
1175 * it in this order for correct visibility of LATERAL references.
1176 */
1178 &l_nsitem,
1179 &l_namespace);
1180
1181 /*
1182 * Make the left-side RTEs available for LATERAL access within the
1183 * right side, by temporarily adding them to the pstate's namespace
1184 * list. Per SQL:2008, if the join type is not INNER or LEFT then the
1185 * left-side names must still be exposed, but it's an error to
1186 * reference them. (Stupid design, but that's what it says.) Hence,
1187 * we always push them into the namespace, but mark them as not
1188 * lateral_ok if the jointype is wrong.
1189 *
1190 * Notice that we don't require the merged namespace list to be
1191 * conflict-free. See the comments for scanNameSpaceForRefname().
1192 */
1195
1198
1199 /* And now we can process the RHS */
1201 &r_nsitem,
1202 &r_namespace);
1203
1204 /* Remove the left-side RTEs from the namespace list again */
1206 sv_namespace_length);
1207
1208 /*
1209 * Check for conflicting refnames in left and right subtrees. Must do
1210 * this because higher levels will assume I hand back a self-
1211 * consistent namespace list.
1212 */
1214
1215 /*
1216 * Generate combined namespace info for possible use below.
1217 */
1219
1220 /*
1221 * We'll work from the nscolumns data and eref alias column names for
1222 * each of the input nsitems. Note that these include dropped
1223 * columns, which is helpful because we can keep track of physical
1224 * input column numbers more easily.
1225 */
1230
1231 /*
1232 * Natural join does not explicitly specify columns; must generate
1233 * columns to join. Need to run through the list of columns from each
1234 * table or join result and match up the column names. Use the first
1235 * table, and check every column in the second table for a match.
1236 * (We'll check that the matches were unique later on.) The result of
1237 * this step is a list of column names just like an explicitly-written
1238 * USING list.
1239 */
1241 {
1244 *rx;
1245
1247
1249 {
1252
1254 continue; /* ignore dropped columns */
1255
1257 {
1259
1261 {
1263 break;
1264 }
1265 }
1266
1267 /* matched a right column? then keep as join column... */
1270 }
1271
1273 }
1274
1275 /*
1276 * If a USING clause alias was specified, save the USING columns as
1277 * its column list.
1278 */
1281
1282 /*
1283 * Now transform the join qualifications, if any.
1284 */
1289
1290 /* this may be larger than needed, but it's not worth being exact */
1294 res_colindex = 0;
1295
1297 {
1298 /*
1299 * JOIN/USING (or NATURAL JOIN, as transformed above). Transform
1300 * the list into an explicit ON-condition.
1301 */
1306
1308
1310 {
1317 *r_colvar;
1318
1320
1321 /* Check for USING(foo,foo) */
1323 {
1325
1330 u_colname)));
1331 }
1332
1333 /* Find it in left input */
1334 ndx = 0;
1336 {
1338
1340 {
1345 u_colname)));
1347 }
1348 ndx++;
1349 }
1354 u_colname)));
1356
1357 /* Find it in right input */
1358 ndx = 0;
1360 {
1362
1364 {
1369 u_colname)));
1371 }
1372 ndx++;
1373 }
1378 u_colname)));
1380
1381 /* Build Vars to use in the generated JOIN ON clause */
1386
1387 /*
1388 * While we're here, add column names to the res_colnames
1389 * list. It's a bit ugly to do this here while the
1390 * corresponding res_colvars entries are not made till later,
1391 * but doing this later would require an additional traversal
1392 * of the usingClause list.
1393 */
1395 }
1396
1397 /* Construct the generated JOIN ON clause */
1399 l_usingvars,
1400 r_usingvars);
1401 }
1403 {
1404 /* User-written ON-condition; transform it */
1406 }
1407 else
1408 {
1409 /* CROSS JOIN: no quals */
1410 }
1411
1412 /*
1413 * If this is an outer join, now mark the appropriate child RTEs as
1414 * being nulled by this join. We have finished processing the child
1415 * join expressions as well as the current join's quals, which deal in
1416 * non-nulled input columns. All future references to those RTEs will
1417 * see possibly-nulled values, and we should mark generated Vars to
1418 * account for that. In particular, the join alias Vars that we're
1419 * about to build should reflect the nulling effects of this join.
1420 *
1421 * A difficulty with doing this is that we need the join's RT index,
1422 * which we don't officially have yet. However, no other RTE can get
1423 * made between here and the addRangeTableEntryForJoin call, so we can
1424 * predict what the assignment will be. (Alternatively, we could call
1425 * addRangeTableEntryForJoin before we have all the data computed, but
1426 * this seems less ugly.)
1427 */
1429
1431 {
1433 break;
1436 break;
1440 break;
1443 break;
1444 default:
1445 /* shouldn't see any other types here */
1448 break;
1449 }
1450
1451 /*
1452 * Now we can construct join alias expressions for the USING columns.
1453 */
1455 {
1457 *lc2;
1458
1459 /* Scan the colnos lists to recover info from the previous loop */
1461 {
1465 *r_colvar;
1468
1469 /*
1470 * Note we re-build these Vars: they might have different
1471 * varnullingrels than the ones made in the previous loop.
1472 */
1475
1476 /* Construct the join alias Var for this column */
1478 j->jointype,
1479 l_colvar,
1480 r_colvar);
1482
1483 /* Construct column's res_nscolumns[] entry */
1485 res_colindex++;
1487 {
1488 /* Merged column is equivalent to left input */
1490 }
1492 {
1493 /* Merged column is equivalent to right input */
1495 }
1496 else
1497 {
1498 /*
1499 * Merged column is not semantically equivalent to either
1500 * input, so it needs to be referenced as the join output
1501 * column.
1502 */
1510 }
1511 }
1512 }
1513
1514 /* Add remaining columns from each side to the output columns */
1515 res_colindex +=
1516 extractRemainingColumns(pstate,
1520 res_colindex +=
1521 extractRemainingColumns(pstate,
1525
1526 /* If join has an alias, it syntactically hides all inputs */
1528 {
1530 {
1532
1534 nscol->p_varattnosyn = k + 1;
1535 }
1536 }
1537
1538 /*
1539 * Now build an RTE and nsitem for the result of the join.
1540 */
1542 res_colnames,
1543 res_nscolumns,
1544 j->jointype,
1546 res_colvars,
1547 l_colnos,
1548 r_colnos,
1549 j->join_using_alias,
1550 j->alias,
1551 true);
1552
1553 /* Verify that we correctly predicted the join's RT index */
1555 /* Cross-check number of columns, too */
1557
1558 /*
1559 * Save a link to the JoinExpr in the proper element of p_joinexprs.
1560 * Since we maintain that list lazily, it may be necessary to fill in
1561 * empty entries before we can add the JoinExpr in the right place.
1562 */
1567
1568 /*
1569 * If the join has a USING alias, build a ParseNamespaceItem for that
1570 * and add it to the list of nsitems in the join's input.
1571 */
1573 {
1575
1581 /* no need to copy the first N columns, just use res_nscolumns */
1583 /* set default visibility flags; might get changed later */
1589 /* Per SQL, we must check for alias conflicts */
1592 }
1593
1594 /*
1595 * Prepare returned namespace list. If the JOIN has an alias then it
1596 * hides the contained RTEs completely; otherwise, the contained RTEs
1597 * are still visible as table names, but are not visible for
1598 * unqualified column-name access.
1599 *
1600 * Note: if there are nested alias-less JOINs, the lower-level ones
1601 * will remain in the list although they have neither p_rel_visible
1602 * nor p_cols_visible set. We could delete such list items, but it's
1603 * unclear that it's worth expending cycles to do so.
1604 */
1607 else
1609
1610 /*
1611 * The join RTE itself is always made visible for unqualified column
1612 * names. It's visible as a relation name only if it has an alias.
1613 */
1618
1621
1623 }
1624 else
1627}
static Node * transformJoinOnClause(ParseState *pstate, JoinExpr *j, List *namespace)
Definition parse_clause.c:365
static int extractRemainingColumns(ParseState *pstate, ParseNamespaceColumn *src_nscolumns, List *src_colnames, List **src_colnos, List **res_colnames, List **res_colvars, ParseNamespaceColumn *res_nscolumns)
Definition parse_clause.c:253
static ParseNamespaceItem * transformRangeSubselect(ParseState *pstate, RangeSubselect *r)
Definition parse_clause.c:405
static ParseNamespaceItem * transformRangeTableFunc(ParseState *pstate, RangeTableFunc *rtf)
Definition parse_clause.c:686
static void setNamespaceColumnVisibility(List *namespace, bool cols_visible)
Definition parse_clause.c:1815
static ParseNamespaceItem * getNSItemForSpecialRelationTypes(ParseState *pstate, RangeVar *rv)
Definition parse_clause.c:1011
static TableSampleClause * transformRangeTableSample(ParseState *pstate, RangeTableSample *rts)
Definition parse_clause.c:908
static Node * transformJoinUsingClause(ParseState *pstate, List *leftVars, List *rightVars)
Definition parse_clause.c:306
static Node * buildMergedJoinVar(ParseState *pstate, JoinType jointype, Var *l_colvar, Var *r_colvar)
Definition parse_clause.c:1666
static ParseNamespaceItem * transformTableEntry(ParseState *pstate, RangeVar *r)
Definition parse_clause.c:395
static ParseNamespaceItem * transformRangeFunction(ParseState *pstate, RangeFunction *r)
Definition parse_clause.c:463
ParseNamespaceItem * transformJsonTable(ParseState *pstate, JsonTable *jt)
Definition parse_jsontable.c:74
ParseNamespaceItem * addRangeTableEntryForJoin(ParseState *pstate, List *colnames, ParseNamespaceColumn *nscolumns, JoinType jointype, int nummergedcols, List *aliasvars, List *leftcols, List *rightcols, Alias *join_using_alias, Alias *alias, bool inFromCl)
Definition parse_relation.c:2229
Definition parsenodes.h:1915
Definition parse_node.h:329
Definition parsenodes.h:666
Definition parsenodes.h:644
Definition parsenodes.h:684
Definition parsenodes.h:724
Definition parsenodes.h:1085
Definition primnodes.h:73
References addRangeTableEntryForJoin(), Assert, buildMergedJoinVar(), buildVarFromNSColumn(), check_stack_depth(), checkNameSpaceConflicts(), elog, ereport, errcode(), errmsg(), ERROR, exprCollation(), exprLocation(), exprType(), exprTypmod(), extractRemainingColumns(), fb(), forboth, getNSItemForSpecialRelationTypes(), IsA, j, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, lappend(), lappend_int(), lfirst, lfirst_int, list_concat(), list_length(), list_make1, list_truncate(), makeNode, makeString(), markRelsAsNulledBy(), NIL, nodeTag, ParseState::p_joinexprs, ParseState::p_namespace, ParseState::p_rtable, ParseNamespaceColumn::p_varnosyn, palloc0(), palloc_object, parser_errposition(), RTE_RELATION, setNamespaceColumnVisibility(), setNamespaceLateralState(), strVal, transformFromClauseItem(), transformJoinOnClause(), transformJoinUsingClause(), transformJsonTable(), transformRangeFunction(), transformRangeSubselect(), transformRangeTableFunc(), transformRangeTableSample(), transformTableEntry(), and VAR_RETURNING_DEFAULT.
Referenced by transformFromClause(), and transformFromClauseItem().
◆ transformGroupClause()
| List * transformGroupClause | ( | ParseState * | pstate, |
| List * | grouplist, | ||
| bool | groupByAll, | ||
| List ** | groupingSets, | ||
| List ** | targetlist, | ||
| List * | sortClause, | ||
| ParseExprKind | exprKind, | ||
| bool | useSQL99 | ||
| ) |
Definition at line 2636 of file parse_clause.c.
2640{
2647
2648 /* Handle GROUP BY ALL */
2649 if (groupByAll)
2650 {
2651 /* There cannot have been any explicit grouplist items */
2653
2654 /* Iterate over targets, adding acceptable ones to the result list */
2656 {
2657 /* Ignore junk TLEs */
2659 continue;
2660
2661 /*
2662 * TLEs containing aggregates are not okay to add to GROUP BY
2663 * (compare checkTargetlistEntrySQL92). But the SQL standard
2664 * directs us to skip them, so it's fine.
2665 */
2668 continue;
2669
2670 /*
2671 * Likewise, TLEs containing window functions are not okay to add
2672 * to GROUP BY. At this writing, the SQL standard is silent on
2673 * what to do with them, but by analogy to aggregates we'll just
2674 * skip them.
2675 */
2678 continue;
2679
2680 /*
2681 * Otherwise, add the TLE to the result using default sort/group
2682 * semantics. We specify the parse location as the TLE's
2683 * location, despite the comment for addTargetToGroupList
2684 * discouraging that. The only other thing we could point to is
2685 * the ALL keyword, which seems unhelpful when there are multiple
2686 * TLEs.
2687 */
2689 result, *targetlist,
2691 }
2692
2693 /* If we found any acceptable targets, we're done */
2695 return result;
2696
2697 /*
2698 * Otherwise, the SQL standard says to treat it like "GROUP BY ()".
2699 * Build a representation of that, and let the rest of this function
2700 * handle it.
2701 */
2703 }
2704
2705 /*
2706 * Recursively flatten implicit RowExprs. (Technically this is only needed
2707 * for GROUP BY, per the syntax rules for grouping sets, but we do it
2708 * anyway.)
2709 */
2711 true,
2712 &hasGroupingSets);
2713
2714 /*
2715 * If the list is now empty, but hasGroupingSets is true, it's because we
2716 * elided redundant empty grouping sets. Restore a single empty grouping
2717 * set to leave a canonical form: GROUP BY ()
2718 */
2719
2721 {
2723 NIL,
2725 }
2726
2728 {
2730
2732 {
2734
2736 {
2739 break;
2741 /* can't happen */
2743 break;
2747 gsets = lappend(gsets,
2748 transformGroupingSet(&result,
2749 pstate, gset,
2750 targetlist, sortClause,
2752 break;
2753 }
2754 }
2755 else
2756 {
2758 pstate, gexpr,
2759 targetlist, sortClause,
2761
2763 {
2766 gsets = lappend(gsets,
2770 }
2771 }
2772 }
2773
2774 /* parser should prevent this */
2776
2777 if (groupingSets)
2778 *groupingSets = gsets;
2779
2780 return result;
2781}
static Index transformGroupClauseExpr(List **flatresult, Bitmapset *seen_local, ParseState *pstate, Node *gexpr, List **targetlist, List *sortClause, ParseExprKind exprKind, bool useSQL99, bool toplevel)
Definition parse_clause.c:2367
static Node * transformGroupingSet(List **flatresult, ParseState *pstate, GroupingSet *gset, List **targetlist, List *sortClause, ParseExprKind exprKind, bool useSQL99, bool toplevel)
Definition parse_clause.c:2528
References addTargetToGroupList(), Assert, bms_add_member(), contain_aggs_of_level(), contain_windowfuncs(), exprLocation(), fb(), flatten_grouping_sets(), foreach_ptr, GROUPING_SET_CUBE, GROUPING_SET_EMPTY, GROUPING_SET_ROLLUP, GROUPING_SET_SETS, GROUPING_SET_SIMPLE, IsA, lappend(), lfirst, list_make1, list_make1_int, makeGroupingSet(), NIL, ParseState::p_hasAggs, ParseState::p_hasWindowFuncs, transformGroupClauseExpr(), and transformGroupingSet().
Referenced by transformSelectStmt(), and transformWindowDefinitions().
◆ transformGroupClauseExpr()
|
static |
Definition at line 2367 of file parse_clause.c.
2371{
2373 bool found = false;
2374
2377 targetlist, exprKind);
2378 else
2380 targetlist, exprKind);
2381
2383 {
2385
2386 /*
2387 * Eliminate duplicates (GROUP BY x, x) but only at local level.
2388 * (Duplicates in grouping sets can affect the number of returned
2389 * rows, so can't be dropped indiscriminately.)
2390 *
2391 * Since we don't care about anything except the sortgroupref, we can
2392 * use a bitmapset rather than scanning lists.
2393 */
2395 return 0;
2396
2397 /*
2398 * If we're already in the flat clause list, we don't need to consider
2399 * adding ourselves again.
2400 */
2402 if (found)
2404
2405 /*
2406 * If the GROUP BY tlist entry also appears in ORDER BY, copy operator
2407 * info from the (first) matching ORDER BY item. This means that if
2408 * you write something like "GROUP BY foo ORDER BY foo USING <<<", the
2409 * GROUP BY operation silently takes on the equality semantics implied
2410 * by the ORDER BY. There are two reasons to do this: it improves the
2411 * odds that we can implement both GROUP BY and ORDER BY with a single
2412 * sort step, and it allows the user to choose the equality semantics
2413 * used by GROUP BY, should she be working with a datatype that has
2414 * more than one equality operator.
2415 *
2416 * If we're in a grouping set, though, we force our requested ordering
2417 * to be NULLS LAST, because if we have any hope of using a sorted agg
2418 * for the job, we're going to be tacking on generated NULL values
2419 * after the corresponding groups. If the user demands nulls first,
2420 * another sort step is going to be inevitable, but that's the
2421 * planner's problem.
2422 */
2423
2425 {
2427
2429 {
2431
2432 if (!toplevel)
2435 found = true;
2436 break;
2437 }
2438 }
2439 }
2440
2441 /*
2442 * If no match in ORDER BY, just add it to the result using default
2443 * sort/group semantics.
2444 */
2445 if (!found)
2447 *flatresult, *targetlist,
2449
2450 /*
2451 * _something_ must have assigned us a sortgroupref by now...
2452 */
2453
2455}
References addTargetToGroupList(), bms_is_member(), copyObject, exprLocation(), fb(), findTargetlistEntrySQL92(), findTargetlistEntrySQL99(), InvalidOid, lappend(), lfirst, and targetIsInSortList().
Referenced by transformGroupClause(), transformGroupClauseList(), and transformGroupingSet().
◆ transformGroupClauseList()
|
static |
Definition at line 2475 of file parse_clause.c.
2479{
2483
2485 {
2487
2489 seen_local,
2490 pstate,
2491 gexpr,
2492 targetlist,
2493 sortClause,
2494 exprKind,
2495 useSQL99,
2496 toplevel);
2497
2499 {
2502 }
2503 }
2504
2505 return result;
2506}
References bms_add_member(), fb(), lappend_int(), lfirst, NIL, and transformGroupClauseExpr().
Referenced by transformGroupingSet().
◆ transformGroupingSet()
|
static |
Definition at line 2528 of file parse_clause.c.
2532{
2535
2537
2539 {
2541
2543 {
2545 pstate, (List *) n,
2546 targetlist, sortClause,
2548
2550 l,
2551 exprLocation(n)));
2552 }
2554 {
2556
2558 pstate, gset2,
2559 targetlist, sortClause,
2561 }
2562 else
2563 {
2565 NULL,
2566 pstate,
2567 n,
2568 targetlist,
2569 sortClause,
2570 exprKind,
2571 useSQL99,
2572 false);
2573
2576 exprLocation(n)));
2577 }
2578 }
2579
2580 /* Arbitrarily cap the size of CUBE, which has exponential growth */
2582 {
2588 }
2589
2591}
static List * transformGroupClauseList(List **flatresult, ParseState *pstate, List *list, List **targetlist, List *sortClause, ParseExprKind exprKind, bool useSQL99, bool toplevel)
Definition parse_clause.c:2475
References Assert, ereport, errcode(), errmsg(), ERROR, exprLocation(), fb(), GROUPING_SET_CUBE, GROUPING_SET_SETS, GROUPING_SET_SIMPLE, IsA, lappend(), lfirst, list_length(), list_make1_int, makeGroupingSet(), NIL, parser_errposition(), transformGroupClauseExpr(), transformGroupClauseList(), and transformGroupingSet().
Referenced by transformGroupClause(), and transformGroupingSet().
◆ transformJoinOnClause()
|
static |
Definition at line 365 of file parse_clause.c.
366{
367 Node *result;
369
370 /*
371 * The namespace that the join expression should see is just the two
372 * subtrees of the JOIN plus any outer references from upper pstate
373 * levels. Temporarily set this pstate's namespace accordingly. (We need
374 * not check for refname conflicts, because transformFromClauseItem()
375 * already did.) All namespace items are marked visible regardless of
376 * LATERAL state.
377 */
379
382
385
387
388 return result;
389}
Node * transformWhereClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName)
Definition parse_clause.c:1854
References EXPR_KIND_JOIN_ON, fb(), j, ParseState::p_namespace, setNamespaceLateralState(), and transformWhereClause().
Referenced by transformFromClauseItem().
◆ transformJoinUsingClause()
|
static |
Definition at line 306 of file parse_clause.c.
308{
309 Node *result;
312 *rvars;
313
314 /*
315 * We cheat a little bit here by building an untransformed operator tree
316 * whose leaves are the already-transformed Vars. This requires collusion
317 * from transformExpr(), which normally could be expected to complain
318 * about already-transformed subnodes. However, this does mean that we
319 * have to mark the columns as requiring SELECT privilege for ourselves;
320 * transformExpr() won't do it.
321 */
323 {
327
328 /* Require read access to the join variables */
331
332 /* Now create the lvar = rvar join condition */
335 -1);
336
337 /* Prepare to combine into an AND clause, if multiple join columns */
339 }
340
341 /* Only need an AND if there's more than one join column */
344 else
346
347 /*
348 * Since the references are already Vars, and are certainly from the input
349 * relations, we don't have to go through the same pushups that
350 * transformJoinOnClause() does. Just invoke transformExpr() to fix up
351 * the operators, and we're done.
352 */
354
356
357 return result;
358}
Expr * makeBoolExpr(BoolExprType boolop, List *args, int location)
Definition makefuncs.c:420
A_Expr * makeSimpleA_Expr(A_Expr_Kind kind, char *name, Node *lexpr, Node *rexpr, int location)
Definition makefuncs.c:48
Node * coerce_to_boolean(ParseState *pstate, Node *node, const char *constructName)
Definition parse_coerce.c:1160
void markVarForSelectPriv(ParseState *pstate, Var *var)
Definition parse_relation.c:1161
Definition parsenodes.h:347
References AEXPR_OP, AND_EXPR, coerce_to_boolean(), copyObject, EXPR_KIND_JOIN_USING, fb(), forboth, lappend(), lfirst, linitial, list_length(), makeBoolExpr(), makeSimpleA_Expr(), markVarForSelectPriv(), NIL, and transformExpr().
Referenced by transformFromClauseItem().
◆ transformLimitClause()
| Node * transformLimitClause | ( | ParseState * | pstate, |
| Node * | clause, | ||
| ParseExprKind | exprKind, | ||
| const char * | constructName, | ||
| LimitOption | limitOption | ||
| ) |
Definition at line 1881 of file parse_clause.c.
1884{
1885 Node *qual;
1886
1889
1891
1893
1894 /* LIMIT can't refer to any variables of the current query */
1896
1897 /*
1898 * Don't allow NULLs in FETCH FIRST .. WITH TIES. This test is ugly and
1899 * extremely simplistic, in that you can pass a NULL anyway by hiding it
1900 * inside an expression -- but this protects ruleutils against emitting an
1901 * unadorned NULL that's not accepted back by the grammar.
1902 */
1908
1909 return qual;
1910}
References castNode, checkExprIsVarFree(), coerce_to_specific_type(), ereport, errcode(), errmsg(), ERROR, EXPR_KIND_LIMIT, fb(), IsA, LIMIT_OPTION_WITH_TIES, and transformExpr().
Referenced by transformSelectStmt(), transformSetOperationStmt(), and transformValuesClause().
◆ transformOnConflictArbiter()
| void transformOnConflictArbiter | ( | ParseState * | pstate, |
| OnConflictClause * | onConflictClause, | ||
| List ** | arbiterExpr, | ||
| Node ** | arbiterWhere, | ||
| Oid * | constraint | ||
| ) |
Definition at line 3365 of file parse_clause.c.
3369{
3371
3373 *arbiterWhere = NULL;
3374 *constraint = InvalidOid;
3375
3381 parser_errposition(pstate,
3383
3384 /*
3385 * To simplify certain aspects of its design, speculative insertion into
3386 * system catalogs is disallowed
3387 */
3392 parser_errposition(pstate,
3394
3395 /* Same applies to table used by logical decoding as catalog table */
3401 parser_errposition(pstate,
3403
3404 /* ON CONFLICT DO NOTHING does not require an inference clause */
3405 if (infer)
3406 {
3409 pstate->p_target_relation);
3410
3411 /*
3412 * Handling inference WHERE clause (for partial unique index
3413 * inference)
3414 */
3417 EXPR_KIND_INDEX_PREDICATE);
3418
3419 /*
3420 * If the arbiter is specified by constraint name, get the constraint
3421 * OID and mark the constrained columns as requiring SELECT privilege,
3422 * in the same way as would have happened if the arbiter had been
3423 * specified by explicit reference to the constraint's index columns.
3424 */
3426 {
3430
3432 false, constraint);
3433
3434 /* Make sure the rel as a whole is marked for SELECT access */
3436 /* Mark the constrained columns as requiring SELECT access */
3438 conattnos);
3439 }
3440 }
3441
3442 /*
3443 * It's convenient to form a list of expressions based on the
3444 * representation used by CREATE INDEX, since the same restrictions are
3445 * appropriate (e.g. on subqueries). However, from here on, a dedicated
3446 * primnode representation is used for inference elements, and so
3447 * assign_query_collations() can be trusted to do the right thing with the
3448 * post parse analysis query tree inference clause representation.
3449 */
3450}
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:916
static List * resolve_unique_index_expr(ParseState *pstate, InferClause *infer, Relation heapRel)
Definition parse_clause.c:3264
Bitmapset * get_relation_constraint_attnos(Oid relid, const char *conname, bool missing_ok, Oid *constraintOid)
Definition pg_constraint.c:1240
Definition parsenodes.h:1665
Definition parsenodes.h:1344
References ACL_SELECT, OnConflictClause::action, bms_add_members(), InferClause::conname, ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_INDEX_PREDICATE, exprLocation(), fb(), get_relation_constraint_attnos(), InferClause::indexElems, OnConflictClause::infer, InvalidOid, IsCatalogRelation(), NIL, ONCONFLICT_UPDATE, ParseNamespaceItem::p_perminfo, ParseState::p_target_nsitem, ParseState::p_target_relation, parser_errposition(), RelationGetRelationName, RelationGetRelid, RelationIsUsedAsCatalogTable, resolve_unique_index_expr(), transformExpr(), and InferClause::whereClause.
Referenced by transformOnConflictClause().
◆ transformRangeFunction()
|
static |
Definition at line 463 of file parse_clause.c.
464{
470
471 /*
472 * We make lateral_only names of this level visible, whether or not the
473 * RangeFunction is explicitly marked LATERAL. This is needed for SQL
474 * spec compliance in the case of UNNEST(), and seems useful on
475 * convenience grounds for all functions in FROM.
476 *
477 * (LATERAL can't nest within a single pstate level, so we don't need
478 * save/restore logic here.)
479 */
482
483 /*
484 * Transform the raw expressions.
485 *
486 * While transforming, also save function names for possible use as alias
487 * and column names. We use the same transformation rules as for a SELECT
488 * output expression. For a FuncCall node, the result will be the
489 * function name, but it is possible for the grammar to hand back other
490 * node types.
491 *
492 * We have to get this info now, because FigureColname only works on raw
493 * parsetrees. Actually deciding what to do with the names is left up to
494 * addRangeTableEntryForFunction.
495 *
496 * Likewise, collect column definition lists if there were any. But
497 * complain if we find one here and the RangeFunction has one too.
498 */
500 {
503 List *coldeflist;
506
507 /* Disassemble the function-call/column-def-list pairs */
511
512 /*
513 * If we find a function call unnest() with more than one argument and
514 * no special decoration, transform it into separate unnest() calls on
515 * each argument. This is a kluge, for sure, but it's less nasty than
516 * other ways of implementing the SQL-standard UNNEST() syntax.
517 *
518 * If there is any decoration (including a coldeflist), we don't
519 * transform, which probably means a no-such-function error later. We
520 * could alternatively throw an error right now, but that doesn't seem
521 * tremendously helpful. If someone is using any such decoration,
522 * then they're not using the SQL-standard syntax, and they're more
523 * likely expecting an un-tweaked function call.
524 *
525 * Note: the transformation changes a non-schema-qualified unnest()
526 * function name into schema-qualified pg_catalog.unnest(). This
527 * choice is also a bit debatable, but it seems reasonable to force
528 * use of built-in unnest() when we make this transformation.
529 */
531 {
533
540 !fc->agg_star &&
541 !fc->agg_distinct &&
542 !fc->func_variadic &&
543 coldeflist == NIL)
544 {
546
548 {
551
553
556 COERCE_EXPLICIT_CALL,
557 fc->location);
558
560 EXPR_KIND_FROM_FUNCTION);
561
562 /* nodeFunctionscan.c requires SRFs to be at top level */
568 parser_errposition(pstate,
570
572
575
576 /* coldeflist is empty, so no error is possible */
577
579 }
580 continue; /* done with this function item */
581 }
582 }
583
584 /* normal case ... */
586
588 EXPR_KIND_FROM_FUNCTION);
589
590 /* nodeFunctionscan.c requires SRFs to be at top level */
596 parser_errposition(pstate,
598
600
603
608 parser_errposition(pstate,
610
612 }
613
615
616 /*
617 * We must assign collations now so that the RTE exposes correct collation
618 * info for Vars created from it.
619 */
621
622 /*
623 * Install the top-level coldeflist if there was one (we already checked
624 * that there was no conflicting per-function coldeflist).
625 *
626 * We only allow this when there's a single function (even after UNNEST
627 * expansion) and no WITH ORDINALITY. The reason for the latter
628 * restriction is that it's not real clear whether the ordinality column
629 * should be in the coldeflist, and users are too likely to make mistakes
630 * in one direction or the other. Putting the coldeflist inside ROWS
631 * FROM() is much clearer in this case.
632 */
634 {
636 {
642 parser_errposition(pstate,
644 else
648 errhint("Use separate UNNEST() calls inside ROWS FROM(), and attach a column definition list to each one."),
649 parser_errposition(pstate,
651 }
657 parser_errposition(pstate,
659
661 }
662
663 /*
664 * Mark the RTE as LATERAL if the user said LATERAL explicitly, or if
665 * there are any lateral cross-references in it.
666 */
668
669 /*
670 * OK, build an RTE and nsitem for the function.
671 */
675}
FuncCall * makeFuncCall(List *name, List *args, CoercionForm funcformat, int location)
Definition makefuncs.c:676
void assign_list_collations(ParseState *pstate, List *exprs)
Definition parse_collate.c:155
ParseNamespaceItem * addRangeTableEntryForFunction(ParseState *pstate, List *funcnames, List *funcexprs, List *coldeflists, RangeFunction *rangefunc, bool lateral, bool inFromCl)
Definition parse_relation.c:1747
List * SystemFuncName(char *name)
Definition parsenodes.h:449
References addRangeTableEntryForFunction(), arg, Assert, assign_list_collations(), COERCE_EXPLICIT_CALL, RangeFunction::coldeflist, contain_vars_of_level(), ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_FROM_FUNCTION, exprLocation(), fb(), fc(), FigureColname(), RangeFunction::functions, RangeFunction::is_rowsfrom, IsA, lappend(), RangeFunction::lateral, lfirst, linitial, list_length(), list_make1, lsecond, makeFuncCall(), NIL, RangeFunction::ordinality, ParseState::p_last_srf, ParseState::p_lateral_active, parser_errposition(), strVal, SystemFuncName(), and transformExpr().
Referenced by transformFromClauseItem().
◆ transformRangeSubselect()
|
static |
Definition at line 405 of file parse_clause.c.
406{
407 Query *query;
408
409 /*
410 * Set p_expr_kind to show this parse level is recursing to a subselect.
411 * We can't be nested within any expression, so don't need save-restore
412 * logic here.
413 */
416
417 /*
418 * If the subselect is LATERAL, make lateral_only names of this level
419 * visible to it. (LATERAL can't nest within a single pstate level, so we
420 * don't need save/restore logic here.)
421 */
424
425 /*
426 * Analyze and transform the subquery. Note that if the subquery doesn't
427 * have an alias, it can't be explicitly selected for locking, but locking
428 * might still be required (if there is an all-tables locking clause).
429 */
431 isLockedRefname(pstate,
433 r->alias->aliasname),
434 true);
435
436 /* Restore state */
439
440 /*
441 * Check that we got a SELECT. Anything else should be impossible given
442 * restrictions of the grammar, but check anyway.
443 */
447
448 /*
449 * OK, build an RTE and nsitem for the subquery.
450 */
452 query,
453 r->alias,
454 r->lateral,
455 true);
456}
bool isLockedRefname(ParseState *pstate, const char *refname)
Definition parse_relation.c:2662
ParseNamespaceItem * addRangeTableEntryForSubquery(ParseState *pstate, Query *subquery, Alias *alias, bool lateral, bool inFromCl)
Definition parse_relation.c:1651
Query * parse_sub_analyze(Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
Definition analyze.c:234
Definition parsenodes.h:118
References addRangeTableEntryForSubquery(), RangeSubselect::alias, Alias::aliasname, Assert, CMD_SELECT, Query::commandType, elog, ERROR, EXPR_KIND_FROM_SUBSELECT, EXPR_KIND_NONE, fb(), IsA, isLockedRefname(), RangeSubselect::lateral, ParseState::p_expr_kind, ParseState::p_lateral_active, parse_sub_analyze(), and RangeSubselect::subquery.
Referenced by transformFromClauseItem().
◆ transformRangeTableFunc()
|
static |
Definition at line 686 of file parse_clause.c.
687{
693 char **names;
694 int colno;
695
696 /*
697 * Currently we only support XMLTABLE here. See transformJsonTable() for
698 * JSON_TABLE support.
699 */
703
704 /*
705 * We make lateral_only names of this level visible, whether or not the
706 * RangeTableFunc is explicitly marked LATERAL. This is needed for SQL
707 * spec compliance and seems useful on convenience grounds for all
708 * functions in FROM.
709 *
710 * (LATERAL can't nest within a single pstate level, so we don't need
711 * save/restore logic here.)
712 */
715
716 /* Transform and apply typecast to the row-generating expression ... */
720 TEXTOID,
721 constructName);
723
724 /* ... and to the document itself */
728 docType,
729 constructName);
731
732 /* undef ordinality column number */
733 tf->ordinalitycol = -1;
734
735 /* Process column specs */
737
738 colno = 0;
740 {
742 Oid typid;
743 int32 typmod;
744 Node *colexpr;
745 Node *coldefexpr;
747
748 tf->colnames = lappend(tf->colnames,
750
751 /*
752 * Determine the type and typmod for the new column. FOR ORDINALITY
753 * columns are INTEGER per spec; the others are user-specified.
754 */
756 {
757 if (tf->ordinalitycol != -1)
762
763 typid = INT4OID;
764 typmod = -1;
765 tf->ordinalitycol = colno;
766 }
767 else
768 {
773 rawc->colname),
775
777 &typid, &typmod);
778 }
779
780 tf->coltypes = lappend_oid(tf->coltypes, typid);
781 tf->coltypmods = lappend_int(tf->coltypmods, typmod);
782 tf->colcollations = lappend_oid(tf->colcollations,
783 get_typcollation(typid));
784
785 /* Transform the PATH and DEFAULT expressions */
787 {
788 colexpr = coerce_to_specific_type(pstate,
790 EXPR_KIND_FROM_FUNCTION),
791 TEXTOID,
792 constructName);
793 assign_expr_collations(pstate, colexpr);
794 }
795 else
796 colexpr = NULL;
797
799 {
800 coldefexpr = coerce_to_specific_type_typmod(pstate,
802 EXPR_KIND_FROM_FUNCTION),
803 typid, typmod,
804 constructName);
805 assign_expr_collations(pstate, coldefexpr);
806 }
807 else
808 coldefexpr = NULL;
809
811 tf->coldefexprs = lappend(tf->coldefexprs, coldefexpr);
812
814 tf->notnulls = bms_add_member(tf->notnulls, colno);
815
816 /* make sure column names are unique */
822 rawc->colname),
824 names[colno] = rawc->colname;
825
826 colno++;
827 }
828 pfree(names);
829
830 /* Namespaces, if any, also need to be transformed */
832 {
833 ListCell *ns;
838
840 {
843
850
851 /* Verify consistency of name list: no dupes, only one DEFAULT */
853 {
855 {
857
859 continue;
864 r->name),
866 }
867 }
868 else
869 {
876 }
877
878 /* We represent DEFAULT by a null pointer */
879 ns_names = lappend(ns_names,
881 }
882
883 tf->ns_uris = ns_uris;
884 tf->ns_names = ns_names;
885 }
886
888
890
891 /*
892 * Mark the RTE as LATERAL if the user said LATERAL explicitly, or if
893 * there are any lateral cross-references in it.
894 */
896
899}
Node * coerce_to_specific_type_typmod(ParseState *pstate, Node *node, Oid targetTypeId, int32 targetTypmod, const char *constructName)
Definition parse_coerce.c:1207
ParseNamespaceItem * addRangeTableEntryForTableFunc(ParseState *pstate, TableFunc *tf, Alias *alias, bool lateral, bool inFromCl)
Definition parse_relation.c:2062
void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
Definition parse_type.c:310
Definition parsenodes.h:702
Definition parsenodes.h:543
Definition primnodes.h:111
References addRangeTableEntryForTableFunc(), Assert, assign_expr_collations(), bms_add_member(), coerce_to_specific_type(), coerce_to_specific_type_typmod(), TableFunc::colexprs, contain_vars_of_level(), TableFunc::docexpr, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_FROM_FUNCTION, fb(), TableFunc::functype, get_typcollation(), IsA, j, lappend(), lappend_int(), lappend_oid(), lfirst, lfirst_node, list_length(), ResTarget::location, TableFunc::location, makeNode, makeString(), ResTarget::name, NIL, ParseState::p_lateral_active, palloc_array, parser_errposition(), pfree(), pstrdup(), TableFunc::rowexpr, strVal, TFT_XMLTABLE, transformExpr(), typenameTypeIdAndMod(), and ResTarget::val.
Referenced by transformFromClauseItem().
◆ transformRangeTableSample()
|
static |
Definition at line 908 of file parse_clause.c.
909{
910 TableSampleClause *tablesample;
915 ListCell *larg,
916 *ltyp;
917
918 /*
919 * To validate the sample method name, look up the handler function, which
920 * has the same name, one dummy INTERNAL argument, and a result type of
921 * tsm_handler. (Note: tablesample method names are not schema-qualified
922 * in the SQL standard; but since they are just functions to us, we allow
923 * schema qualification to resolve any potential ambiguity.)
924 */
926
928
929 /* we want error to complain about no-such-method, not no-such-function */
936
937 /* check that handler has correct return type */
944
945 /* OK, run the handler to get TsmRoutine, for argument type info */
947
950
951 /* check user provided the expected number of arguments */
956 "tablesample method %s requires %d arguments, not %d",
962
963 /*
964 * Transform the arguments, typecasting them as needed. Note we must also
965 * assign collations now, because assign_query_collations() doesn't
966 * examine any substructure of RTEs.
967 */
970 {
973
978 }
980
981 /* Process REPEATABLE (seed) */
983 {
985
992
997 }
998 else
1000
1001 return tablesample;
1002}
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition elog.c:1193
Oid LookupFuncName(List *funcname, int nargs, const Oid *argtypes, bool missing_ok)
Definition parse_func.c:2269
Definition parsenodes.h:1402
Definition tsmapi.h:57
References arg, TableSampleClause::args, assign_expr_collations(), coerce_to_specific_type(), ereport, errcode(), errmsg(), errmsg_plural(), ERROR, EXPR_KIND_FROM_FUNCTION, fb(), forboth, get_func_rettype(), GetTsmRoutine(), lappend(), lfirst, lfirst_oid, list_length(), LookupFuncName(), makeNode, NameListToString(), NIL, OidIsValid, parser_errposition(), TableSampleClause::repeatable, transformExpr(), and TableSampleClause::tsmhandler.
Referenced by transformFromClauseItem().
◆ transformSortClause()
| List * transformSortClause | ( | ParseState * | pstate, |
| List * | orderlist, | ||
| List ** | targetlist, | ||
| ParseExprKind | exprKind, | ||
| bool | useSQL99 | ||
| ) |
Definition at line 2794 of file parse_clause.c.
2799{
2802
2804 {
2807
2810 targetlist, exprKind);
2811 else
2813 targetlist, exprKind);
2814
2817 }
2818
2820}
List * addTargetToSortList(ParseState *pstate, TargetEntry *tle, List *sortlist, List *targetlist, SortBy *sortby)
Definition parse_clause.c:3461
Definition parsenodes.h:572
References addTargetToSortList(), fb(), findTargetlistEntrySQL92(), findTargetlistEntrySQL99(), lfirst, and NIL.
Referenced by transformAggregateCall(), transformSelectStmt(), transformSetOperationStmt(), transformValuesClause(), and transformWindowDefinitions().
◆ transformTableEntry()
|
static |
Definition at line 395 of file parse_clause.c.
396{
397 /* addRangeTableEntry does all the work */
399}
ParseNamespaceItem * addRangeTableEntry(ParseState *pstate, RangeVar *relation, Alias *alias, bool inh, bool inFromCl)
Definition parse_relation.c:1483
References addRangeTableEntry(), RangeVar::alias, and RangeVar::inh.
Referenced by transformFromClauseItem().
◆ transformWhereClause()
| Node * transformWhereClause | ( | ParseState * | pstate, |
| Node * | clause, | ||
| ParseExprKind | exprKind, | ||
| const char * | constructName | ||
| ) |
Definition at line 1854 of file parse_clause.c.
References coerce_to_boolean(), fb(), and transformExpr().
Referenced by AlterPolicy(), CreatePolicy(), CreateTriggerFiringOn(), ParseFuncOrColumn(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformDeleteStmt(), transformIndexStmt(), transformJoinOnClause(), transformJsonAggConstructor(), transformMergeStmt(), transformOnConflictClause(), TransformPubWhereClauses(), transformRuleStmt(), transformSelectStmt(), and transformUpdateStmt().
◆ transformWindowDefinitions()
| List * transformWindowDefinitions | ( | ParseState * | pstate, |
| List * | windowdefs, | ||
| List ** | targetlist | ||
| ) |
Definition at line 2827 of file parse_clause.c.
2830{
2832 Index winref = 0;
2834
2836 {
2839 List *partitionClause;
2840 List *orderClause;
2843 WindowClause *wc;
2844
2845 winref++;
2846
2847 /*
2848 * Check for duplicate window names.
2849 */
2856
2857 /*
2858 * If it references a previous window, look that up.
2859 */
2861 {
2867 windef->refname),
2869 }
2870
2871 /*
2872 * Transform PARTITION and ORDER specs, if any. These are treated
2873 * almost exactly like top-level GROUP BY and ORDER BY clauses,
2874 * including the special handling of nondefault operator semantics.
2875 */
2876 orderClause = transformSortClause(pstate,
2877 windef->orderClause,
2878 targetlist,
2879 EXPR_KIND_WINDOW_ORDER,
2880 true /* force SQL99 rules */ );
2881 partitionClause = transformGroupClause(pstate,
2882 windef->partitionClause,
2883 false /* not GROUP BY ALL */ ,
2884 NULL,
2885 targetlist,
2886 orderClause,
2888 true /* force SQL99 rules */ );
2889
2890 /*
2891 * And prepare the new WindowClause.
2892 */
2894 wc->name = windef->name;
2895 wc->refname = windef->refname;
2896
2897 /*
2898 * Per spec, a windowdef that references a previous one copies the
2899 * previous partition clause (and mustn't specify its own). It can
2900 * specify its own ordering clause, but only if the previous one had
2901 * none. It always specifies its own frame clause, and the previous
2902 * one must not have a frame clause. Yeah, it's bizarre that each of
2903 * these cases works differently, but SQL:2008 says so; see 7.11
2904 * <window clause> syntax rule 10 and general rule 1. The frame
2905 * clause rule is especially bizarre because it makes "OVER foo"
2906 * different from "OVER (foo)", and requires the latter to throw an
2907 * error if foo has a nondefault frame clause. Well, ours not to
2908 * reason why, but we do go out of our way to throw a useful error
2909 * message for such cases.
2910 */
2912 {
2913 if (partitionClause)
2917 windef->refname),
2920 }
2921 else
2922 wc->partitionClause = partitionClause;
2924 {
2929 windef->refname),
2931 if (orderClause)
2932 {
2933 wc->orderClause = orderClause;
2934 wc->copiedOrder = false;
2935 }
2936 else
2937 {
2939 wc->copiedOrder = true;
2940 }
2941 }
2942 else
2943 {
2944 wc->orderClause = orderClause;
2945 wc->copiedOrder = false;
2946 }
2948 {
2949 /*
2950 * Use this message if this is a WINDOW clause, or if it's an OVER
2951 * clause that includes ORDER BY or framing clauses. (We already
2952 * rejected PARTITION BY above, so no need to check that.)
2953 */
2959 windef->refname),
2961 /* Else this clause is just OVER (foo), so say this: */
2965 windef->refname),
2968 }
2970
2971 /*
2972 * RANGE offset PRECEDING/FOLLOWING requires exactly one ORDER BY
2973 * column; check that and get its sort opfamily info.
2974 */
2977 FRAMEOPTION_END_OFFSET)))
2978 {
2982
2990 /* Find the sort operator in pg_amop */
2992 &rangeopfamily,
2993 &rangeopcintype,
2994 &rangecmptype))
2996 sortcl->sortop);
2997 /* Record properties of sort ordering */
2999 wc->inRangeAsc = !sortcl->reverse_sort;
3000 wc->inRangeNullsFirst = sortcl->nulls_first;
3001 }
3002
3003 /* Per spec, GROUPS mode requires an ORDER BY clause */
3005 {
3011 }
3012
3013 /* Process frame offset expressions */
3016 &wc->startInRangeFunc,
3020 &wc->endInRangeFunc,
3022 wc->winref = winref;
3023
3024 result = lappend(result, wc);
3025 }
3026
3027 return result;
3028}
bool get_ordering_op_properties(Oid opno, Oid *opfamily, Oid *opcintype, CompareType *cmptype)
Definition lsyscache.c:259
List * transformGroupClause(ParseState *pstate, List *grouplist, bool groupByAll, List **groupingSets, List **targetlist, List *sortClause, ParseExprKind exprKind, bool useSQL99)
Definition parse_clause.c:2636
List * transformSortClause(ParseState *pstate, List *orderlist, List **targetlist, ParseExprKind exprKind, bool useSQL99)
Definition parse_clause.c:2794
static Node * transformFrameOffset(ParseState *pstate, int frameOptions, Oid rangeopfamily, Oid rangeopcintype, Oid *inRangeFunc, Node *clause)
Definition parse_clause.c:3757
static WindowClause * findWindowClause(List *wclist, const char *name)
Definition parse_clause.c:3730
Definition parsenodes.h:590
Node * get_sortgroupclause_expr(SortGroupClause *sgClause, List *targetList)
Definition tlist.c:388
References copyObject, elog, WindowClause::endOffset, ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_WINDOW_ORDER, EXPR_KIND_WINDOW_PARTITION, exprCollation(), fb(), findWindowClause(), FRAMEOPTION_DEFAULTS, FRAMEOPTION_END_OFFSET, FRAMEOPTION_GROUPS, FRAMEOPTION_RANGE, FRAMEOPTION_START_OFFSET, WindowClause::frameOptions, get_ordering_op_properties(), get_sortgroupclause_expr(), InvalidOid, lappend(), lfirst, linitial_node, list_length(), makeNode, NIL, WindowClause::orderClause, parser_errposition(), WindowClause::partitionClause, WindowClause::startOffset, transformFrameOffset(), transformGroupClause(), transformSortClause(), and WindowClause::winref.
Referenced by transformSelectStmt().
