parse_clause.h File Reference

#include "parser/parse_node.h"

Include dependency graph for parse_clause.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	transformFromClause (ParseState *pstate, List *frmList)
int	setTargetTable (ParseState *pstate, RangeVar *relation, bool inh, bool alsoSource, AclMode requiredPerms)
Node *	transformWhereClause (ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName)
Node *	transformLimitClause (ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName, LimitOption limitOption)
List *	transformGroupClause (ParseState *pstate, List *grouplist, bool groupByAll, List **groupingSets, List **targetlist, List *sortClause, ParseExprKind exprKind, bool useSQL99)
List *	transformSortClause (ParseState *pstate, List *orderlist, List **targetlist, ParseExprKind exprKind, bool useSQL99)
List *	transformWindowDefinitions (ParseState *pstate, List *windowdefs, List **targetlist)
List *	transformDistinctClause (ParseState *pstate, List **targetlist, List *sortClause, bool is_agg)
List *	transformDistinctOnClause (ParseState *pstate, List *distinctlist, List **targetlist, List *sortClause)
void	transformOnConflictArbiter (ParseState *pstate, OnConflictClause *onConflictClause, List **arbiterExpr, Node **arbiterWhere, Oid *constraint)
List *	addTargetToSortList (ParseState *pstate, TargetEntry *tle, List *sortlist, List *targetlist, SortBy *sortby)
Index	assignSortGroupRef (TargetEntry *tle, List *tlist)
bool	targetIsInSortList (TargetEntry *tle, Oid sortop, List *sortList)
ParseNamespaceItem *	transformJsonTable (ParseState *pstate, JsonTable *jt)

Function Documentation

addTargetToSortList()

List * addTargetToSortList ( ParseState *  pstate, TargetEntry *  tle, List *  sortlist, List *  targetlist, SortBy *  sortby  )

extern

Definition at line 3607 of file parse_clause.c.

{
    Oid         restype = exprType((Node *) tle->expr);
    Oid         sortop;
    Oid         eqop;
    bool        hashable;
    bool        reverse;
    int         location;
    ParseCallbackState pcbstate;
 
    /* if tlist item is an UNKNOWN literal, change it to TEXT */
    if (restype == UNKNOWNOID)
    {
        tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr,
                                         restype, TEXTOID, -1,
                                         COERCION_IMPLICIT,
                                         COERCE_IMPLICIT_CAST,
                                         -1);
        restype = TEXTOID;
    }
 
    /*
     * Rather than clutter the API of get_sort_group_operators and the other
     * functions we're about to use, make use of error context callback to
     * mark any error reports with a parse position.  We point to the operator
     * location if present, else to the expression being sorted.  (NB: use the
     * original untransformed expression here; the TLE entry might well point
     * at a duplicate expression in the regular SELECT list.)
     */
    location = sortby->location;
    if (location < 0)
        location = exprLocation(sortby->node);
    setup_parser_errposition_callback(&pcbstate, pstate, location);
 
    /* determine the sortop, eqop, and directionality */
    switch (sortby->sortby_dir)
    {
        case SORTBY_DEFAULT:
        case SORTBY_ASC:
            get_sort_group_operators(restype,
                                     true, true, false,
                                     &sortop, &eqop, NULL,
                                     &hashable);
            reverse = false;
            break;
        case SORTBY_DESC:
            get_sort_group_operators(restype,
                                     false, true, true,
                                     NULL, &eqop, &sortop,
                                     &hashable);
            reverse = true;
            break;
        case SORTBY_USING:
            Assert(sortby->useOp != NIL);
            sortop = compatible_oper_opid(sortby->useOp,
                                          restype,
                                          restype,
                                          false);
 
            /*
             * Verify it's a valid ordering operator, fetch the corresponding
             * equality operator, and determine whether to consider it like
             * ASC or DESC.
             */
            eqop = get_equality_op_for_ordering_op(sortop, &reverse);
            if (!OidIsValid(eqop))
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("operator %s is not a valid ordering operator",
                                strVal(llast(sortby->useOp))),
                         errhint("Ordering operators must be \"<\" or \">\" members of btree operator families.")));
 
            /*
             * Also see if the equality operator is hashable.
             */
            hashable = op_hashjoinable(eqop, restype);
            break;
        default:
            elog(ERROR, "unrecognized sortby_dir: %d", sortby->sortby_dir);
            sortop = InvalidOid;    /* keep compiler quiet */
            eqop = InvalidOid;
            hashable = false;
            reverse = false;
            break;
    }
 
    cancel_parser_errposition_callback(&pcbstate);
 
    /* avoid making duplicate sortlist entries */
    if (!targetIsInSortList(tle, sortop, sortlist))
    {
        SortGroupClause *sortcl = makeNode(SortGroupClause);
 
        sortcl->tleSortGroupRef = assignSortGroupRef(tle, targetlist);
 
        sortcl->eqop = eqop;
        sortcl->sortop = sortop;
        sortcl->hashable = hashable;
        sortcl->reverse_sort = reverse;
 
        switch (sortby->sortby_nulls)
        {
            case SORTBY_NULLS_DEFAULT:
                /* NULLS FIRST is default for DESC; other way for ASC */
                sortcl->nulls_first = reverse;
                break;
            case SORTBY_NULLS_FIRST:
                sortcl->nulls_first = true;
                break;
            case SORTBY_NULLS_LAST:
                sortcl->nulls_first = false;
                break;
            default:
                elog(ERROR, "unrecognized sortby_nulls: %d",
                     sortby->sortby_nulls);
                break;
        }
 
        sortlist = lappend(sortlist, sortcl);
    }
 
    return sortlist;
}

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  )

extern

Definition at line 3808 of file parse_clause.c.

{
    Index       maxRef;
    ListCell   *l;
 
    if (tle->ressortgroupref)   /* already has one? */
        return tle->ressortgroupref;
 
    /* easiest way to pick an unused refnumber: max used + 1 */
    maxRef = 0;
    foreach(l, tlist)
    {
        Index       ref = ((TargetEntry *) lfirst(l))->ressortgroupref;
 
        if (ref > maxRef)
            maxRef = ref;
    }
    tle->ressortgroupref = maxRef + 1;
    return tle->ressortgroupref;
}

References fb(), and lfirst.

Referenced by addTargetToGroupList(), addTargetToSortList(), build_minmax_path(), create_unique_paths(), generate_setop_child_grouplist(), and transformDistinctOnClause().

setTargetTable()

int setTargetTable ( ParseState *  pstate, RangeVar *  relation, bool  inh, bool  alsoSource, AclMode  requiredPerms  )

extern

Definition at line 182 of file parse_clause.c.

{
    ParseNamespaceItem *nsitem;
 
    /*
     * ENRs hide tables of the same name, so we need to check for them first.
     * In contrast, CTEs don't hide tables (for this purpose).
     */
    if (relation->schemaname == NULL &&
        scanNameSpaceForENR(pstate, relation->relname))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("relation \"%s\" cannot be the target of a modifying statement",
                        relation->relname)));
 
    /* Close old target; this could only happen for multi-action rules */
    if (pstate->p_target_relation != NULL)
        table_close(pstate->p_target_relation, NoLock);
 
    /*
     * Open target rel and grab suitable lock (which we will hold till end of
     * transaction).
     *
     * free_parsestate() will eventually do the corresponding table_close(),
     * but *not* release the lock.
     */
    pstate->p_target_relation = parserOpenTable(pstate, relation,
                                                RowExclusiveLock);
 
    /*
     * Now build an RTE and a ParseNamespaceItem.
     */
    nsitem = addRangeTableEntryForRelation(pstate, pstate->p_target_relation,
                                           RowExclusiveLock,
                                           relation->alias, inh, false);
 
    /* remember the RTE/nsitem as being the query target */
    pstate->p_target_nsitem = nsitem;
 
    /*
     * Override addRangeTableEntry's default ACL_SELECT permissions check, and
     * instead mark target table as requiring exactly the specified
     * permissions.
     *
     * If we find an explicit reference to the rel later during parse
     * analysis, we will add the ACL_SELECT bit back again; see
     * markVarForSelectPriv and its callers.
     */
    nsitem->p_perminfo->requiredPerms = requiredPerms;
 
    /*
     * If UPDATE/DELETE, add table to joinlist and namespace.
     */
    if (alsoSource)
        addNSItemToQuery(pstate, nsitem, true, true, true);
 
    return nsitem->p_rtindex;
}

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  )

extern

Definition at line 3849 of file parse_clause.c.

{
    Index       ref = tle->ressortgroupref;
    ListCell   *l;
 
    /* no need to scan list if tle has no marker */
    if (ref == 0)
        return false;
 
    foreach(l, sortList)
    {
        SortGroupClause *scl = (SortGroupClause *) lfirst(l);
 
        if (scl->tleSortGroupRef == ref &&
            (sortop == InvalidOid ||
             sortop == scl->sortop ||
             sortop == get_commutator(scl->sortop)))
            return true;
    }
    return false;
}

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  )

extern

Definition at line 3192 of file parse_clause.c.

{
    List       *result = NIL;
    ListCell   *slitem;
    ListCell   *tlitem;
 
    /*
     * The distinctClause should consist of all ORDER BY items followed by all
     * other non-resjunk targetlist items.  There must not be any resjunk
     * ORDER BY items --- that would imply that we are sorting by a value that
     * isn't necessarily unique within a DISTINCT group, so the results
     * wouldn't be well-defined.  This construction ensures we follow the rule
     * that sortClause and distinctClause match; in fact the sortClause will
     * always be a prefix of distinctClause.
     *
     * Note a corner case: the same TLE could be in the ORDER BY list multiple
     * times with different sortops.  We have to include it in the
     * distinctClause the same way to preserve the prefix property. The net
     * effect will be that the TLE value will be made unique according to both
     * sortops.
     */
    foreach(slitem, sortClause)
    {
        SortGroupClause *scl = (SortGroupClause *) lfirst(slitem);
        TargetEntry *tle = get_sortgroupclause_tle(scl, *targetlist);
 
        if (tle->resjunk)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                     is_agg ?
                     errmsg("in an aggregate with DISTINCT, ORDER BY expressions must appear in argument list") :
                     errmsg("for SELECT DISTINCT, ORDER BY expressions must appear in select list"),
                     parser_errposition(pstate,
                                        exprLocation((Node *) tle->expr))));
        result = lappend(result, copyObject(scl));
    }
 
    /*
     * Now add any remaining non-resjunk tlist items, using default sort/group
     * semantics for their data types.
     */
    foreach(tlitem, *targetlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(tlitem);
 
        if (tle->resjunk)
            continue;           /* ignore junk */
        result = addTargetToGroupList(pstate, tle,
                                      result, *targetlist,
                                      exprLocation((Node *) tle->expr));
    }
 
    /*
     * Complain if we found nothing to make DISTINCT.  Returning an empty list
     * would cause the parsed Query to look like it didn't have DISTINCT, with
     * results that would probably surprise the user.  Note: this case is
     * presently impossible for aggregates because of grammar restrictions,
     * but we check anyway.
     */
    if (result == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 is_agg ?
                 errmsg("an aggregate with DISTINCT must have at least one argument") :
                 errmsg("SELECT DISTINCT must have at least one column")));
 
    return result;
}

References addTargetToGroupList(), copyObject, ereport, errcode(), errmsg, ERROR, exprLocation(), fb(), get_sortgroupclause_tle(), lappend(), lfirst, NIL, parser_errposition(), and result.

Referenced by transformAggregateCall(), and transformSelectStmt().

transformDistinctOnClause()

List * transformDistinctOnClause ( ParseState *  pstate, List *  distinctlist, List **  targetlist, List *  sortClause  )

extern

Definition at line 3276 of file parse_clause.c.

{
    List       *result = NIL;
    List       *sortgrouprefs = NIL;
    bool        skipped_sortitem;
    ListCell   *lc;
    ListCell   *lc2;
 
    /*
     * Add all the DISTINCT ON expressions to the tlist (if not already
     * present, they are added as resjunk items).  Assign sortgroupref numbers
     * to them, and make a list of these numbers.  (NB: we rely below on the
     * sortgrouprefs list being one-for-one with the original distinctlist.
     * Also notice that we could have duplicate DISTINCT ON expressions and
     * hence duplicate entries in sortgrouprefs.)
     */
    foreach(lc, distinctlist)
    {
        Node       *dexpr = (Node *) lfirst(lc);
        int         sortgroupref;
        TargetEntry *tle;
 
        tle = findTargetlistEntrySQL92(pstate, dexpr, targetlist,
                                       EXPR_KIND_DISTINCT_ON);
        sortgroupref = assignSortGroupRef(tle, *targetlist);
        sortgrouprefs = lappend_int(sortgrouprefs, sortgroupref);
    }
 
    /*
     * If the user writes both DISTINCT ON and ORDER BY, adopt the sorting
     * semantics from ORDER BY items that match DISTINCT ON items, and also
     * adopt their column sort order.  We insist that the distinctClause and
     * sortClause match, so throw error if we find the need to add any more
     * distinctClause items after we've skipped an ORDER BY item that wasn't
     * in DISTINCT ON.
     */
    skipped_sortitem = false;
    foreach(lc, sortClause)
    {
        SortGroupClause *scl = (SortGroupClause *) lfirst(lc);
 
        if (list_member_int(sortgrouprefs, scl->tleSortGroupRef))
        {
            if (skipped_sortitem)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                         errmsg("SELECT DISTINCT ON expressions must match initial ORDER BY expressions"),
                         parser_errposition(pstate,
                                            get_matching_location(scl->tleSortGroupRef,
                                                                  sortgrouprefs,
                                                                  distinctlist))));
            else
                result = lappend(result, copyObject(scl));
        }
        else
            skipped_sortitem = true;
    }
 
    /*
     * Now add any remaining DISTINCT ON items, using default sort/group
     * semantics for their data types.  (Note: this is pretty questionable; if
     * the ORDER BY list doesn't include all the DISTINCT ON items and more
     * besides, you certainly aren't using DISTINCT ON in the intended way,
     * and you probably aren't going to get consistent results.  It might be
     * better to throw an error or warning here.  But historically we've
     * allowed it, so keep doing so.)
     */
    forboth(lc, distinctlist, lc2, sortgrouprefs)
    {
        Node       *dexpr = (Node *) lfirst(lc);
        int         sortgroupref = lfirst_int(lc2);
        TargetEntry *tle = get_sortgroupref_tle(sortgroupref, *targetlist);
 
        if (targetIsInSortList(tle, InvalidOid, result))
            continue;           /* already in list (with some semantics) */
        if (skipped_sortitem)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                     errmsg("SELECT DISTINCT ON expressions must match initial ORDER BY expressions"),
                     parser_errposition(pstate, exprLocation(dexpr))));
        result = addTargetToGroupList(pstate, tle,
                                      result, *targetlist,
                                      exprLocation(dexpr));
    }
 
    /*
     * An empty result list is impossible here because of grammar
     * restrictions.
     */
    Assert(result != NIL);
 
    return result;
}

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(), result, and targetIsInSortList().

Referenced by transformSelectStmt().

transformFromClause()

void transformFromClause ( ParseState *  pstate, List *  frmList  )

extern

Definition at line 116 of file parse_clause.c.

{
    ListCell   *fl;
 
    /*
     * 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 namespace.
     *
     * Note we must process the items left-to-right for proper handling of
     * LATERAL references.
     */
    foreach(fl, frmList)
    {
        Node       *n = lfirst(fl);
        ParseNamespaceItem *nsitem;
        List       *namespace;
 
        n = transformFromClauseItem(pstate, n,
                                    &nsitem,
                                    &namespace);
 
        checkNameSpaceConflicts(pstate, pstate->p_namespace, namespace);
 
        /* Mark the new namespace items as visible only to LATERAL */
        setNamespaceLateralState(namespace, true, true);
 
        pstate->p_joinlist = lappend(pstate->p_joinlist, n);
        pstate->p_namespace = list_concat(pstate->p_namespace, namespace);
    }
 
    /*
     * We're done parsing the FROM list, so make all namespace items
     * unconditionally visible.  Note that this will also reset lateral_only
     * for any namespace items that were already present when we were called;
     * but those should have been that way already.
     */
    setNamespaceLateralState(pstate->p_namespace, false, true);
}

References checkNameSpaceConflicts(), fb(), lappend(), lfirst, list_concat(), ParseState::p_joinlist, ParseState::p_namespace, setNamespaceLateralState(), and transformFromClauseItem().

Referenced by transformDeleteStmt(), transformMergeStmt(), transformSelectStmt(), and transformUpdateStmt().

transformGroupClause()

List * transformGroupClause ( ParseState *  pstate, List *  grouplist, bool  groupByAll, List **  groupingSets, List **  targetlist, List *  sortClause, ParseExprKind  exprKind, bool  useSQL99  )

extern

Definition at line 2780 of file parse_clause.c.

{
    List       *result = NIL;
    List       *flat_grouplist;
    List       *gsets = NIL;
    ListCell   *gl;
    bool        hasGroupingSets = false;
    Bitmapset  *seen_local = NULL;
 
    /* Handle GROUP BY ALL */
    if (groupByAll)
    {
        /* There cannot have been any explicit grouplist items */
        Assert(grouplist == NIL);
 
        /* Iterate over targets, adding acceptable ones to the result list */
        foreach_ptr(TargetEntry, tle, *targetlist)
        {
            /* Ignore junk TLEs */
            if (tle->resjunk)
                continue;
 
            /*
             * TLEs containing aggregates are not okay to add to GROUP BY
             * (compare checkTargetlistEntrySQL92).  But the SQL standard
             * directs us to skip them, so it's fine.
             */
            if (pstate->p_hasAggs &&
                contain_aggs_of_level((Node *) tle->expr, 0))
                continue;
 
            /*
             * Likewise, TLEs containing window functions are not okay to add
             * to GROUP BY.  At this writing, the SQL standard is silent on
             * what to do with them, but by analogy to aggregates we'll just
             * skip them.
             */
            if (pstate->p_hasWindowFuncs &&
                contain_windowfuncs((Node *) tle->expr))
                continue;
 
            /*
             * Otherwise, add the TLE to the result using default sort/group
             * semantics.  We specify the parse location as the TLE's
             * location, despite the comment for addTargetToGroupList
             * discouraging that.  The only other thing we could point to is
             * the ALL keyword, which seems unhelpful when there are multiple
             * TLEs.
             */
            result = addTargetToGroupList(pstate, tle,
                                          result, *targetlist,
                                          exprLocation((Node *) tle->expr));
        }
 
        /* If we found any acceptable targets, we're done */
        if (result != NIL)
            return result;
 
        /*
         * Otherwise, the SQL standard says to treat it like "GROUP BY ()".
         * Build a representation of that, and let the rest of this function
         * handle it.
         */
        grouplist = list_make1(makeGroupingSet(GROUPING_SET_EMPTY, NIL, -1));
    }
 
    /*
     * Recursively flatten implicit RowExprs. (Technically this is only needed
     * for GROUP BY, per the syntax rules for grouping sets, but we do it
     * anyway.)
     */
    flat_grouplist = (List *) flatten_grouping_sets((Node *) grouplist,
                                                    true,
                                                    &hasGroupingSets);
 
    /*
     * If the list is now empty, but hasGroupingSets is true, it's because we
     * elided redundant empty grouping sets. Restore a single empty grouping
     * set to leave a canonical form: GROUP BY ()
     */
 
    if (flat_grouplist == NIL && hasGroupingSets)
    {
        flat_grouplist = list_make1(makeGroupingSet(GROUPING_SET_EMPTY,
                                                    NIL,
                                                    exprLocation((Node *) grouplist)));
    }
 
    foreach(gl, flat_grouplist)
    {
        Node       *gexpr = (Node *) lfirst(gl);
 
        if (IsA(gexpr, GroupingSet))
        {
            GroupingSet *gset = (GroupingSet *) gexpr;
 
            switch (gset->kind)
            {
                case GROUPING_SET_EMPTY:
                    gsets = lappend(gsets, gset);
                    break;
                case GROUPING_SET_SIMPLE:
                    /* can't happen */
                    Assert(false);
                    break;
                case GROUPING_SET_SETS:
                case GROUPING_SET_CUBE:
                case GROUPING_SET_ROLLUP:
                    gsets = lappend(gsets,
                                    transformGroupingSet(&result,
                                                         pstate, gset,
                                                         targetlist, sortClause,
                                                         exprKind, useSQL99, true));
                    break;
            }
        }
        else
        {
            Index       ref = transformGroupClauseExpr(&result, seen_local,
                                                       pstate, gexpr,
                                                       targetlist, sortClause,
                                                       exprKind, useSQL99, true);
 
            if (ref > 0)
            {
                seen_local = bms_add_member(seen_local, ref);
                if (hasGroupingSets)
                    gsets = lappend(gsets,
                                    makeGroupingSet(GROUPING_SET_SIMPLE,
                                                    list_make1_int(ref),
                                                    exprLocation(gexpr)));
            }
        }
    }
 
    /* parser should prevent this */
    Assert(gsets == NIL || groupingSets != NULL);
 
    if (groupingSets)
        *groupingSets = gsets;
 
    return result;
}

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, result, transformGroupClauseExpr(), and transformGroupingSet().

Referenced by transformSelectStmt(), and transformWindowDefinitions().

transformJsonTable()

ParseNamespaceItem * transformJsonTable ( ParseState *  pstate, JsonTable *  jt  )

extern

Definition at line 74 of file parse_jsontable.c.

{
    TableFunc  *tf;
    JsonFuncExpr *jfe;
    JsonExpr   *je;
    JsonTablePathSpec *rootPathSpec = jt->pathspec;
    bool        is_lateral;
    JsonTableParseContext cxt = {pstate};
 
    Assert(IsA(rootPathSpec->string, A_Const) &&
           castNode(A_Const, rootPathSpec->string)->val.node.type == T_String);
 
    if (jt->on_error &&
        jt->on_error->btype != JSON_BEHAVIOR_ERROR &&
        jt->on_error->btype != JSON_BEHAVIOR_EMPTY &&
        jt->on_error->btype != JSON_BEHAVIOR_EMPTY_ARRAY)
        ereport(ERROR,
                errcode(ERRCODE_SYNTAX_ERROR),
                errmsg("invalid %s behavior", "ON ERROR"),
                errdetail("Only EMPTY [ ARRAY ] or ERROR is allowed in the top-level ON ERROR clause."),
                parser_errposition(pstate, jt->on_error->location));
 
    cxt.pathNameId = 0;
    if (rootPathSpec->name == NULL)
        rootPathSpec->name = generateJsonTablePathName(&cxt);
    cxt.pathNames = list_make1(rootPathSpec->name);
    CheckDuplicateColumnOrPathNames(&cxt, jt->columns);
 
    /*
     * We make lateral_only names of this level visible, whether or not the
     * RangeTableFunc is explicitly marked LATERAL.  This is needed for SQL
     * spec compliance and seems useful on convenience grounds for all
     * functions in FROM.
     *
     * (LATERAL can't nest within a single pstate level, so we don't need
     * save/restore logic here.)
     */
    Assert(!pstate->p_lateral_active);
    pstate->p_lateral_active = true;
 
    tf = makeNode(TableFunc);
    tf->functype = TFT_JSON_TABLE;
 
    /*
     * Transform JsonFuncExpr representing the top JSON_TABLE context_item and
     * pathspec into a dummy JSON_TABLE_OP JsonExpr.
     */
    jfe = makeNode(JsonFuncExpr);
    jfe->op = JSON_TABLE_OP;
    jfe->context_item = jt->context_item;
    jfe->pathspec = (Node *) rootPathSpec->string;
    jfe->passing = jt->passing;
    jfe->on_empty = NULL;
    jfe->on_error = jt->on_error;
    jfe->location = jt->location;
    tf->docexpr = transformExpr(pstate, (Node *) jfe, EXPR_KIND_FROM_FUNCTION);
 
    /*
     * Create a JsonTablePlan that will generate row pattern that becomes
     * source data for JSON path expressions in jt->columns.  This also adds
     * the columns' transformed JsonExpr nodes into tf->colvalexprs.
     */
    cxt.jt = jt;
    cxt.tf = tf;
    tf->plan = (Node *) transformJsonTableColumns(&cxt, jt->columns,
                                                  jt->passing,
                                                  rootPathSpec);
 
    /*
     * Copy the transformed PASSING arguments into the TableFunc node, because
     * they are evaluated separately from the JsonExpr that we just put in
     * TableFunc.docexpr.  JsonExpr.passing_values is still kept around for
     * get_json_table().
     */
    je = (JsonExpr *) tf->docexpr;
    tf->passingvalexprs = copyObject(je->passing_values);
 
    tf->ordinalitycol = -1;     /* undefine ordinality column number */
    tf->location = jt->location;
 
    pstate->p_lateral_active = false;
 
    /*
     * Mark the RTE as LATERAL if the user said LATERAL explicitly, or if
     * there are any lateral cross-references in it.
     */
    is_lateral = jt->lateral || contain_vars_of_level((Node *) tf, 0);
 
    return addRangeTableEntryForTableFunc(pstate,
                                          tf, jt->alias, is_lateral, true);
}

References addRangeTableEntryForTableFunc(), JsonTable::alias, Assert, JsonBehavior::btype, castNode, CheckDuplicateColumnOrPathNames(), JsonTable::columns, contain_vars_of_level(), JsonTable::context_item, copyObject, TableFunc::docexpr, ereport, errcode(), errdetail(), errmsg, ERROR, EXPR_KIND_FROM_FUNCTION, fb(), TableFunc::functype, generateJsonTablePathName(), IsA, JSON_BEHAVIOR_EMPTY, JSON_BEHAVIOR_EMPTY_ARRAY, JSON_BEHAVIOR_ERROR, JSON_TABLE_OP, JsonTableParseContext::jt, JsonTable::lateral, list_make1, JsonTable::location, TableFunc::location, JsonBehavior::location, makeNode, JsonTable::on_error, ParseState::p_lateral_active, parser_errposition(), JsonTable::passing, JsonTableParseContext::pathNameId, JsonTableParseContext::pathNames, JsonTable::pathspec, JsonTableParseContext::tf, TFT_JSON_TABLE, transformExpr(), and transformJsonTableColumns().

Referenced by transformFromClauseItem().

transformLimitClause()

Node * transformLimitClause ( ParseState *  pstate, Node *  clause, ParseExprKind  exprKind, const char *  constructName, LimitOption  limitOption  )

extern

Definition at line 2025 of file parse_clause.c.

{
    Node       *qual;
 
    if (clause == NULL)
        return NULL;
 
    qual = transformExpr(pstate, clause, exprKind);
 
    qual = coerce_to_specific_type(pstate, qual, INT8OID, constructName);
 
    /* LIMIT can't refer to any variables of the current query */
    checkExprIsVarFree(pstate, qual, constructName);
 
    /*
     * Don't allow NULLs in FETCH FIRST .. WITH TIES.  This test is ugly and
     * extremely simplistic, in that you can pass a NULL anyway by hiding it
     * inside an expression -- but this protects ruleutils against emitting an
     * unadorned NULL that's not accepted back by the grammar.
     */
    if (exprKind == EXPR_KIND_LIMIT && limitOption == LIMIT_OPTION_WITH_TIES &&
        IsA(clause, A_Const) && castNode(A_Const, clause)->isnull)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ROW_COUNT_IN_LIMIT_CLAUSE),
                 errmsg("row count cannot be null in FETCH FIRST ... WITH TIES clause")));
 
    return qual;
}

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  )

extern

Definition at line 3509 of file parse_clause.c.

{
    InferClause *infer = onConflictClause->infer;
 
    *arbiterExpr = NIL;
    *arbiterWhere = NULL;
    *constraint = InvalidOid;
 
    if ((onConflictClause->action == ONCONFLICT_UPDATE ||
         onConflictClause->action == ONCONFLICT_SELECT) && !infer)
        ereport(ERROR,
                errcode(ERRCODE_SYNTAX_ERROR),
                errmsg("ON CONFLICT DO %s requires inference specification or constraint name",
                       onConflictClause->action == ONCONFLICT_UPDATE ? "UPDATE" : "SELECT"),
                errhint("For example, ON CONFLICT (column_name)."),
                parser_errposition(pstate,
                                   exprLocation((Node *) onConflictClause)));
 
    /*
     * To simplify certain aspects of its design, speculative insertion into
     * system catalogs is disallowed
     */
    if (IsCatalogRelation(pstate->p_target_relation))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("ON CONFLICT is not supported with system catalog tables"),
                 parser_errposition(pstate,
                                    exprLocation((Node *) onConflictClause))));
 
    /* Same applies to table used by logical decoding as catalog table */
    if (RelationIsUsedAsCatalogTable(pstate->p_target_relation))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("ON CONFLICT is not supported on table \"%s\" used as a catalog table",
                        RelationGetRelationName(pstate->p_target_relation)),
                 parser_errposition(pstate,
                                    exprLocation((Node *) onConflictClause))));
 
    /* ON CONFLICT DO NOTHING does not require an inference clause */
    if (infer)
    {
        if (infer->indexElems)
            *arbiterExpr = resolve_unique_index_expr(pstate, infer,
                                                     pstate->p_target_relation);
 
        /*
         * Handling inference WHERE clause (for partial unique index
         * inference)
         */
        if (infer->whereClause)
            *arbiterWhere = transformExpr(pstate, infer->whereClause,
                                          EXPR_KIND_INDEX_PREDICATE);
 
        /*
         * If the arbiter is specified by constraint name, get the constraint
         * OID and mark the constrained columns as requiring SELECT privilege,
         * in the same way as would have happened if the arbiter had been
         * specified by explicit reference to the constraint's index columns.
         */
        if (infer->conname)
        {
            Oid         relid = RelationGetRelid(pstate->p_target_relation);
            RTEPermissionInfo *perminfo = pstate->p_target_nsitem->p_perminfo;
            Bitmapset  *conattnos;
 
            conattnos = get_relation_constraint_attnos(relid, infer->conname,
                                                       false, constraint);
 
            /* Make sure the rel as a whole is marked for SELECT access */
            perminfo->requiredPerms |= ACL_SELECT;
            /* Mark the constrained columns as requiring SELECT access */
            perminfo->selectedCols = bms_add_members(perminfo->selectedCols,
                                                     conattnos);
        }
    }
 
    /*
     * It's convenient to form a list of expressions based on the
     * representation used by CREATE INDEX, since the same restrictions are
     * appropriate (e.g. on subqueries).  However, from here on, a dedicated
     * primnode representation is used for inference elements, and so
     * assign_query_collations() can be trusted to do the right thing with the
     * post parse analysis query tree inference clause representation.
     */
}

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_SELECT, 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().

transformSortClause()

List * transformSortClause ( ParseState *  pstate, List *  orderlist, List **  targetlist, ParseExprKind  exprKind, bool  useSQL99  )

extern

Definition at line 2938 of file parse_clause.c.

{
    List       *sortlist = NIL;
    ListCell   *olitem;
 
    foreach(olitem, orderlist)
    {
        SortBy     *sortby = (SortBy *) lfirst(olitem);
        TargetEntry *tle;
 
        if (useSQL99)
            tle = findTargetlistEntrySQL99(pstate, sortby->node,
                                           targetlist, exprKind);
        else
            tle = findTargetlistEntrySQL92(pstate, sortby->node,
                                           targetlist, exprKind);
 
        sortlist = addTargetToSortList(pstate, tle,
                                       sortlist, *targetlist, sortby);
    }
 
    return sortlist;
}

References addTargetToSortList(), fb(), findTargetlistEntrySQL92(), findTargetlistEntrySQL99(), lfirst, and NIL.

Referenced by transformAggregateCall(), transformSelectStmt(), transformSetOperationStmt(), transformValuesClause(), and transformWindowDefinitions().

transformWhereClause()

Node * transformWhereClause ( ParseState *  pstate, Node *  clause, ParseExprKind  exprKind, const char *  constructName  )

extern

Definition at line 1998 of file parse_clause.c.

{
    Node       *qual;
 
    if (clause == NULL)
        return NULL;
 
    qual = transformExpr(pstate, clause, exprKind);
 
    qual = coerce_to_boolean(pstate, qual, constructName);
 
    return qual;
}

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  )

extern

Definition at line 2971 of file parse_clause.c.

{
    List       *result = NIL;
    Index       winref = 0;
    ListCell   *lc;
 
    foreach(lc, windowdefs)
    {
        WindowDef  *windef = (WindowDef *) lfirst(lc);
        WindowClause *refwc = NULL;
        List       *partitionClause;
        List       *orderClause;
        Oid         rangeopfamily = InvalidOid;
        Oid         rangeopcintype = InvalidOid;
        WindowClause *wc;
 
        winref++;
 
        /*
         * Check for duplicate window names.
         */
        if (windef->name &&
            findWindowClause(result, windef->name) != NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_WINDOWING_ERROR),
                     errmsg("window \"%s\" is already defined", windef->name),
                     parser_errposition(pstate, windef->location)));
 
        /*
         * If it references a previous window, look that up.
         */
        if (windef->refname)
        {
            refwc = findWindowClause(result, windef->refname);
            if (refwc == NULL)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("window \"%s\" does not exist",
                                windef->refname),
                         parser_errposition(pstate, windef->location)));
        }
 
        /*
         * Transform PARTITION and ORDER specs, if any.  These are treated
         * almost exactly like top-level GROUP BY and ORDER BY clauses,
         * including the special handling of nondefault operator semantics.
         */
        orderClause = transformSortClause(pstate,
                                          windef->orderClause,
                                          targetlist,
                                          EXPR_KIND_WINDOW_ORDER,
                                          true /* force SQL99 rules */ );
        partitionClause = transformGroupClause(pstate,
                                               windef->partitionClause,
                                               false /* not GROUP BY ALL */ ,
                                               NULL,
                                               targetlist,
                                               orderClause,
                                               EXPR_KIND_WINDOW_PARTITION,
                                               true /* force SQL99 rules */ );
 
        /*
         * And prepare the new WindowClause.
         */
        wc = makeNode(WindowClause);
        wc->name = windef->name;
        wc->refname = windef->refname;
 
        /*
         * Per spec, a windowdef that references a previous one copies the
         * previous partition clause (and mustn't specify its own).  It can
         * specify its own ordering clause, but only if the previous one had
         * none.  It always specifies its own frame clause, and the previous
         * one must not have a frame clause.  Yeah, it's bizarre that each of
         * these cases works differently, but SQL:2008 says so; see 7.11
         * <window clause> syntax rule 10 and general rule 1.  The frame
         * clause rule is especially bizarre because it makes "OVER foo"
         * different from "OVER (foo)", and requires the latter to throw an
         * error if foo has a nondefault frame clause.  Well, ours not to
         * reason why, but we do go out of our way to throw a useful error
         * message for such cases.
         */
        if (refwc)
        {
            if (partitionClause)
                ereport(ERROR,
                        (errcode(ERRCODE_WINDOWING_ERROR),
                         errmsg("cannot override PARTITION BY clause of window \"%s\"",
                                windef->refname),
                         parser_errposition(pstate, windef->location)));
            wc->partitionClause = copyObject(refwc->partitionClause);
        }
        else
            wc->partitionClause = partitionClause;
        if (refwc)
        {
            if (orderClause && refwc->orderClause)
                ereport(ERROR,
                        (errcode(ERRCODE_WINDOWING_ERROR),
                         errmsg("cannot override ORDER BY clause of window \"%s\"",
                                windef->refname),
                         parser_errposition(pstate, windef->location)));
            if (orderClause)
            {
                wc->orderClause = orderClause;
                wc->copiedOrder = false;
            }
            else
            {
                wc->orderClause = copyObject(refwc->orderClause);
                wc->copiedOrder = true;
            }
        }
        else
        {
            wc->orderClause = orderClause;
            wc->copiedOrder = false;
        }
        if (refwc && refwc->frameOptions != FRAMEOPTION_DEFAULTS)
        {
            /*
             * Use this message if this is a WINDOW clause, or if it's an OVER
             * clause that includes ORDER BY or framing clauses.  (We already
             * rejected PARTITION BY above, so no need to check that.)
             */
            if (windef->name ||
                orderClause || windef->frameOptions != FRAMEOPTION_DEFAULTS)
                ereport(ERROR,
                        (errcode(ERRCODE_WINDOWING_ERROR),
                         errmsg("cannot copy window \"%s\" because it has a frame clause",
                                windef->refname),
                         parser_errposition(pstate, windef->location)));
            /* Else this clause is just OVER (foo), so say this: */
            ereport(ERROR,
                    (errcode(ERRCODE_WINDOWING_ERROR),
                     errmsg("cannot copy window \"%s\" because it has a frame clause",
                            windef->refname),
                     errhint("Omit the parentheses in this OVER clause."),
                     parser_errposition(pstate, windef->location)));
        }
        wc->frameOptions = windef->frameOptions;
 
        /*
         * RANGE offset PRECEDING/FOLLOWING requires exactly one ORDER BY
         * column; check that and get its sort opfamily info.
         */
        if ((wc->frameOptions & FRAMEOPTION_RANGE) &&
            (wc->frameOptions & (FRAMEOPTION_START_OFFSET |
                                 FRAMEOPTION_END_OFFSET)))
        {
            SortGroupClause *sortcl;
            Node       *sortkey;
            CompareType rangecmptype;
 
            if (list_length(wc->orderClause) != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_WINDOWING_ERROR),
                         errmsg("RANGE with offset PRECEDING/FOLLOWING requires exactly one ORDER BY column"),
                         parser_errposition(pstate, windef->location)));
            sortcl = linitial_node(SortGroupClause, wc->orderClause);
            sortkey = get_sortgroupclause_expr(sortcl, *targetlist);
            /* Find the sort operator in pg_amop */
            if (!get_ordering_op_properties(sortcl->sortop,
                                            &rangeopfamily,
                                            &rangeopcintype,
                                            &rangecmptype))
                elog(ERROR, "operator %u is not a valid ordering operator",
                     sortcl->sortop);
            /* Record properties of sort ordering */
            wc->inRangeColl = exprCollation(sortkey);
            wc->inRangeAsc = !sortcl->reverse_sort;
            wc->inRangeNullsFirst = sortcl->nulls_first;
        }
 
        /* Per spec, GROUPS mode requires an ORDER BY clause */
        if (wc->frameOptions & FRAMEOPTION_GROUPS)
        {
            if (wc->orderClause == NIL)
                ereport(ERROR,
                        (errcode(ERRCODE_WINDOWING_ERROR),
                         errmsg("GROUPS mode requires an ORDER BY clause"),
                         parser_errposition(pstate, windef->location)));
        }
 
        /* Process frame offset expressions */
        wc->startOffset = transformFrameOffset(pstate, wc->frameOptions,
                                               rangeopfamily, rangeopcintype,
                                               &wc->startInRangeFunc,
                                               windef->startOffset);
        wc->endOffset = transformFrameOffset(pstate, wc->frameOptions,
                                             rangeopfamily, rangeopcintype,
                                             &wc->endInRangeFunc,
                                             windef->endOffset);
        wc->winref = winref;
 
        result = lappend(result, wc);
    }
 
    return result;
}

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, result, WindowClause::startOffset, transformFrameOffset(), transformGroupClause(), transformSortClause(), and WindowClause::winref.

Referenced by transformSelectStmt().