parse_collate.c File Reference

#include "postgres.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_collation.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_collate.h"
#include "utils/lsyscache.h"

Include dependency graph for parse_collate.c:

Go to the source code of this file.

Data Structures
struct	assign_collations_context

Enumerations
enum	CollateStrength { COLLATE_NONE , COLLATE_IMPLICIT , COLLATE_CONFLICT , COLLATE_EXPLICIT }

Functions
static bool	assign_query_collations_walker (Node *node, ParseState *pstate)
static bool	assign_collations_walker (Node *node, assign_collations_context *context)
static void	merge_collation_state (Oid collation, CollateStrength strength, int location, Oid collation2, int location2, assign_collations_context *context)
static void	assign_aggregate_collations (Aggref *aggref, assign_collations_context *loccontext)
static void	assign_ordered_set_collations (Aggref *aggref, assign_collations_context *loccontext)
static void	assign_hypothetical_collations (Aggref *aggref, assign_collations_context *loccontext)
void	assign_query_collations (ParseState *pstate, Query *query)
void	assign_list_collations (ParseState *pstate, List *exprs)
void	assign_expr_collations (ParseState *pstate, Node *expr)
Oid	select_common_collation (ParseState *pstate, List *exprs, bool none_ok)

Enumeration Type Documentation

CollateStrength

enum CollateStrength

Enumerator
COLLATE_NONE
COLLATE_IMPLICIT
COLLATE_CONFLICT
COLLATE_EXPLICIT

Definition at line 56 of file parse_collate.c.

{
    COLLATE_NONE,               /* expression is of a noncollatable datatype */
    COLLATE_IMPLICIT,           /* collation was derived implicitly */
    COLLATE_CONFLICT,           /* we had a conflict of implicit collations */
    COLLATE_EXPLICIT,           /* collation was derived explicitly */
} CollateStrength;

Function Documentation

assign_aggregate_collations()

static void assign_aggregate_collations ( Aggref *  aggref, assign_collations_context *  loccontext  )

static

Definition at line 881 of file parse_collate.c.

{
    ListCell   *lc;
 
    /* Plain aggregates have no direct args */
    Assert(aggref->aggdirectargs == NIL);
 
    /* Process aggregated args, holding resjunk ones at arm's length */
    foreach(lc, aggref->args)
    {
        TargetEntry *tle = lfirst_node(TargetEntry, lc);
 
        if (tle->resjunk)
            assign_expr_collations(loccontext->pstate, (Node *) tle);
        else
            (void) assign_collations_walker((Node *) tle, loccontext);
    }
}

References Aggref::aggdirectargs, Aggref::args, Assert, assign_collations_walker(), assign_expr_collations(), lfirst_node, NIL, and assign_collations_context::pstate.

Referenced by assign_collations_walker().

assign_collations_walker()

static bool assign_collations_walker ( Node *  node, assign_collations_context *  context  )

static

Definition at line 255 of file parse_collate.c.

{
    assign_collations_context loccontext;
    Oid         collation;
    CollateStrength strength;
    int         location;
 
    /* Need do nothing for empty subexpressions */
    if (node == NULL)
        return false;
 
    /*
     * Prepare for recursion.  For most node types, though not all, the first
     * thing we do is recurse to process all nodes below this one. Each level
     * of the tree has its own local context.
     */
    loccontext.pstate = context->pstate;
    loccontext.collation = InvalidOid;
    loccontext.strength = COLLATE_NONE;
    loccontext.location = -1;
    /* Set these fields just to suppress uninitialized-value warnings: */
    loccontext.collation2 = InvalidOid;
    loccontext.location2 = -1;
 
    /*
     * Recurse if appropriate, then determine the collation for this node.
     *
     * Note: the general cases are at the bottom of the switch, after various
     * special cases.
     */
    switch (nodeTag(node))
    {
        case T_CollateExpr:
            {
                /*
                 * COLLATE sets an explicitly derived collation, regardless of
                 * what the child state is.  But we must recurse to set up
                 * collation info below here.
                 */
                CollateExpr *expr = (CollateExpr *) node;
 
                (void) expression_tree_walker(node,
                                              assign_collations_walker,
                                              &loccontext);
 
                collation = expr->collOid;
                Assert(OidIsValid(collation));
                strength = COLLATE_EXPLICIT;
                location = expr->location;
            }
            break;
        case T_FieldSelect:
            {
                /*
                 * For FieldSelect, the result has the field's declared
                 * collation, independently of what happened in the arguments.
                 * (The immediate argument must be composite and thus not
                 * collatable, anyhow.)  The field's collation was already
                 * looked up and saved in the node.
                 */
                FieldSelect *expr = (FieldSelect *) node;
 
                /* ... but first, recurse */
                (void) expression_tree_walker(node,
                                              assign_collations_walker,
                                              &loccontext);
 
                if (OidIsValid(expr->resultcollid))
                {
                    /* Node's result type is collatable. */
                    /* Pass up field's collation as an implicit choice. */
                    collation = expr->resultcollid;
                    strength = COLLATE_IMPLICIT;
                    location = exprLocation(node);
                }
                else
                {
                    /* Node's result type isn't collatable. */
                    collation = InvalidOid;
                    strength = COLLATE_NONE;
                    location = -1;  /* won't be used */
                }
            }
            break;
        case T_RowExpr:
            {
                /*
                 * RowExpr is a special case because the subexpressions are
                 * independent: we don't want to complain if some of them have
                 * incompatible explicit collations.
                 */
                RowExpr    *expr = (RowExpr *) node;
 
                assign_list_collations(context->pstate, expr->args);
 
                /*
                 * Since the result is always composite and therefore never
                 * has a collation, we can just stop here: this node has no
                 * impact on the collation of its parent.
                 */
                return false;   /* done */
            }
        case T_RowCompareExpr:
            {
                /*
                 * For RowCompare, we have to find the common collation of
                 * each pair of input columns and build a list.  If we can't
                 * find a common collation, we just put InvalidOid into the
                 * list, which may or may not cause an error at runtime.
                 */
                RowCompareExpr *expr = (RowCompareExpr *) node;
                List       *colls = NIL;
                ListCell   *l;
                ListCell   *r;
 
                forboth(l, expr->largs, r, expr->rargs)
                {
                    Node       *le = (Node *) lfirst(l);
                    Node       *re = (Node *) lfirst(r);
                    Oid         coll;
 
                    coll = select_common_collation(context->pstate,
                                                   list_make2(le, re),
                                                   true);
                    colls = lappend_oid(colls, coll);
                }
                expr->inputcollids = colls;
 
                /*
                 * Since the result is always boolean and therefore never has
                 * a collation, we can just stop here: this node has no impact
                 * on the collation of its parent.
                 */
                return false;   /* done */
            }
        case T_CoerceToDomain:
            {
                /*
                 * If the domain declaration included a non-default COLLATE
                 * spec, then use that collation as the output collation of
                 * the coercion.  Otherwise allow the input collation to
                 * bubble up.  (The input should be of the domain's base type,
                 * therefore we don't need to worry about it not being
                 * collatable when the domain is.)
                 */
                CoerceToDomain *expr = (CoerceToDomain *) node;
                Oid         typcollation = get_typcollation(expr->resulttype);
 
                /* ... but first, recurse */
                (void) expression_tree_walker(node,
                                              assign_collations_walker,
                                              &loccontext);
 
                if (OidIsValid(typcollation))
                {
                    /* Node's result type is collatable. */
                    if (typcollation == DEFAULT_COLLATION_OID)
                    {
                        /* Collation state bubbles up from child. */
                        collation = loccontext.collation;
                        strength = loccontext.strength;
                        location = loccontext.location;
                    }
                    else
                    {
                        /* Use domain's collation as an implicit choice. */
                        collation = typcollation;
                        strength = COLLATE_IMPLICIT;
                        location = exprLocation(node);
                    }
                }
                else
                {
                    /* Node's result type isn't collatable. */
                    collation = InvalidOid;
                    strength = COLLATE_NONE;
                    location = -1;  /* won't be used */
                }
 
                /*
                 * Save the state into the expression node.  We know it
                 * doesn't care about input collation.
                 */
                if (strength == COLLATE_CONFLICT)
                    exprSetCollation(node, InvalidOid);
                else
                    exprSetCollation(node, collation);
            }
            break;
        case T_TargetEntry:
            (void) expression_tree_walker(node,
                                          assign_collations_walker,
                                          &loccontext);
 
            /*
             * TargetEntry can have only one child, and should bubble that
             * state up to its parent.  We can't use the general-case code
             * below because exprType and friends don't work on TargetEntry.
             */
            collation = loccontext.collation;
            strength = loccontext.strength;
            location = loccontext.location;
 
            /*
             * Throw error if the collation is indeterminate for a TargetEntry
             * that is a sort/group target.  We prefer to do this now, instead
             * of leaving the comparison functions to fail at runtime, because
             * we can give a syntax error pointer to help locate the problem.
             * There are some cases where there might not be a failure, for
             * example if the planner chooses to use hash aggregation instead
             * of sorting for grouping; but it seems better to predictably
             * throw an error.  (Compare transformSetOperationTree, which will
             * throw error for indeterminate collation of set-op columns, even
             * though the planner might be able to implement the set-op
             * without sorting.)
             */
            if (strength == COLLATE_CONFLICT &&
                ((TargetEntry *) node)->ressortgroupref != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_COLLATION_MISMATCH),
                         errmsg("collation mismatch between implicit collations \"%s\" and \"%s\"",
                                get_collation_name(loccontext.collation),
                                get_collation_name(loccontext.collation2)),
                         errhint("You can choose the collation by applying the COLLATE clause to one or both expressions."),
                         parser_errposition(context->pstate,
                                            loccontext.location2)));
            break;
        case T_InferenceElem:
        case T_RangeTblRef:
        case T_JoinExpr:
        case T_FromExpr:
        case T_OnConflictExpr:
        case T_SortGroupClause:
        case T_MergeAction:
            (void) expression_tree_walker(node,
                                          assign_collations_walker,
                                          &loccontext);
 
            /*
             * When we're invoked on a query's jointree, we don't need to do
             * anything with join nodes except recurse through them to process
             * WHERE/ON expressions.  So just stop here.  Likewise, we don't
             * need to do anything when invoked on sort/group lists.
             */
            return false;
        case T_Query:
            {
                /*
                 * We get here when we're invoked on the Query belonging to a
                 * SubLink.  Act as though the Query returns its first output
                 * column, which indeed is what it does for EXPR_SUBLINK and
                 * ARRAY_SUBLINK cases.  In the cases where the SubLink
                 * returns boolean, this info will be ignored.  Special case:
                 * in EXISTS, the Query might return no columns, in which case
                 * we need do nothing.
                 *
                 * We needn't recurse, since the Query is already processed.
                 */
                Query      *qtree = (Query *) node;
                TargetEntry *tent;
 
                if (qtree->targetList == NIL)
                    return false;
                tent = linitial_node(TargetEntry, qtree->targetList);
                if (tent->resjunk)
                    return false;
 
                collation = exprCollation((Node *) tent->expr);
                /* collation doesn't change if it's converted to array */
                strength = COLLATE_IMPLICIT;
                location = exprLocation((Node *) tent->expr);
            }
            break;
        case T_List:
            (void) expression_tree_walker(node,
                                          assign_collations_walker,
                                          &loccontext);
 
            /*
             * When processing a list, collation state just bubbles up from
             * the list elements.
             */
            collation = loccontext.collation;
            strength = loccontext.strength;
            location = loccontext.location;
            break;
 
        case T_Var:
        case T_Const:
        case T_Param:
        case T_CoerceToDomainValue:
        case T_CaseTestExpr:
        case T_SetToDefault:
        case T_CurrentOfExpr:
 
            /*
             * General case for childless expression nodes.  These should
             * already have a collation assigned; it is not this function's
             * responsibility to look into the catalogs for base-case
             * information.
             */
            collation = exprCollation(node);
 
            /*
             * Note: in most cases, there will be an assigned collation
             * whenever type_is_collatable(exprType(node)); but an exception
             * occurs for a Var referencing a subquery output column for which
             * a unique collation was not determinable.  That may lead to a
             * runtime failure if a collation-sensitive function is applied to
             * the Var.
             */
 
            if (OidIsValid(collation))
                strength = COLLATE_IMPLICIT;
            else
                strength = COLLATE_NONE;
            location = exprLocation(node);
            break;
 
        default:
            {
                /*
                 * General case for most expression nodes with children. First
                 * recurse, then figure out what to assign to this node.
                 */
                Oid         typcollation;
 
                /*
                 * For most node types, we want to treat all the child
                 * expressions alike; but there are a few exceptions, hence
                 * this inner switch.
                 */
                switch (nodeTag(node))
                {
                    case T_Aggref:
                        {
                            /*
                             * Aggref is messy enough that we give it its own
                             * function, in fact three of them.  The FILTER
                             * clause is independent of the rest of the
                             * aggregate, however, so it can be processed
                             * separately.
                             */
                            Aggref     *aggref = (Aggref *) node;
 
                            switch (aggref->aggkind)
                            {
                                case AGGKIND_NORMAL:
                                    assign_aggregate_collations(aggref,
                                                                &loccontext);
                                    break;
                                case AGGKIND_ORDERED_SET:
                                    assign_ordered_set_collations(aggref,
                                                                  &loccontext);
                                    break;
                                case AGGKIND_HYPOTHETICAL:
                                    assign_hypothetical_collations(aggref,
                                                                   &loccontext);
                                    break;
                                default:
                                    elog(ERROR, "unrecognized aggkind: %d",
                                         (int) aggref->aggkind);
                            }
 
                            assign_expr_collations(context->pstate,
                                                   (Node *) aggref->aggfilter);
                        }
                        break;
                    case T_WindowFunc:
                        {
                            /*
                             * WindowFunc requires special processing only for
                             * its aggfilter clause, as for aggregates.
                             */
                            WindowFunc *wfunc = (WindowFunc *) node;
 
                            (void) assign_collations_walker((Node *) wfunc->args,
                                                            &loccontext);
 
                            assign_expr_collations(context->pstate,
                                                   (Node *) wfunc->aggfilter);
                        }
                        break;
                    case T_CaseExpr:
                        {
                            /*
                             * CaseExpr is a special case because we do not
                             * want to recurse into the test expression (if
                             * any).  It was already marked with collations
                             * during transformCaseExpr, and furthermore its
                             * collation is not relevant to the result of the
                             * CASE --- only the output expressions are.
                             */
                            CaseExpr   *expr = (CaseExpr *) node;
                            ListCell   *lc;
 
                            foreach(lc, expr->args)
                            {
                                CaseWhen   *when = lfirst_node(CaseWhen, lc);
 
                                /*
                                 * The condition expressions mustn't affect
                                 * the CASE's result collation either; but
                                 * since they are known to yield boolean, it's
                                 * safe to recurse directly on them --- they
                                 * won't change loccontext.
                                 */
                                (void) assign_collations_walker((Node *) when->expr,
                                                                &loccontext);
                                (void) assign_collations_walker((Node *) when->result,
                                                                &loccontext);
                            }
                            (void) assign_collations_walker((Node *) expr->defresult,
                                                            &loccontext);
                        }
                        break;
                    case T_SubscriptingRef:
                        {
                            /*
                             * The subscripts are treated as independent
                             * expressions not contributing to the node's
                             * collation.  Only the container, and the source
                             * expression if any, contribute.  (This models
                             * the old behavior, in which the subscripts could
                             * be counted on to be integers and thus not
                             * contribute anything.)
                             */
                            SubscriptingRef *sbsref = (SubscriptingRef *) node;
 
                            assign_expr_collations(context->pstate,
                                                   (Node *) sbsref->refupperindexpr);
                            assign_expr_collations(context->pstate,
                                                   (Node *) sbsref->reflowerindexpr);
                            (void) assign_collations_walker((Node *) sbsref->refexpr,
                                                            &loccontext);
                            (void) assign_collations_walker((Node *) sbsref->refassgnexpr,
                                                            &loccontext);
                        }
                        break;
                    default:
 
                        /*
                         * Normal case: all child expressions contribute
                         * equally to loccontext.
                         */
                        (void) expression_tree_walker(node,
                                                      assign_collations_walker,
                                                      &loccontext);
                        break;
                }
 
                /*
                 * Now figure out what collation to assign to this node.
                 */
                typcollation = get_typcollation(exprType(node));
                if (OidIsValid(typcollation))
                {
                    /* Node's result is collatable; what about its input? */
                    if (loccontext.strength > COLLATE_NONE)
                    {
                        /* Collation state bubbles up from children. */
                        collation = loccontext.collation;
                        strength = loccontext.strength;
                        location = loccontext.location;
                    }
                    else
                    {
                        /*
                         * Collatable output produced without any collatable
                         * input.  Use the type's collation (which is usually
                         * DEFAULT_COLLATION_OID, but might be different for a
                         * domain).
                         */
                        collation = typcollation;
                        strength = COLLATE_IMPLICIT;
                        location = exprLocation(node);
                    }
                }
                else
                {
                    /* Node's result type isn't collatable. */
                    collation = InvalidOid;
                    strength = COLLATE_NONE;
                    location = -1;  /* won't be used */
                }
 
                /*
                 * Save the result collation into the expression node. If the
                 * state is COLLATE_CONFLICT, we'll set the collation to
                 * InvalidOid, which might result in an error at runtime.
                 */
                if (strength == COLLATE_CONFLICT)
                    exprSetCollation(node, InvalidOid);
                else
                    exprSetCollation(node, collation);
 
                /*
                 * Likewise save the input collation, which is the one that
                 * any function called by this node should use.
                 */
                if (loccontext.strength == COLLATE_CONFLICT)
                    exprSetInputCollation(node, InvalidOid);
                else
                    exprSetInputCollation(node, loccontext.collation);
            }
            break;
    }
 
    /*
     * Now, merge my information into my parent's state.
     */
    merge_collation_state(collation,
                          strength,
                          location,
                          loccontext.collation2,
                          loccontext.location2,
                          context);
 
    return false;
}

References Aggref::aggfilter, WindowFunc::aggfilter, WindowFunc::args, CaseExpr::args, RowExpr::args, Assert, assign_aggregate_collations(), assign_expr_collations(), assign_hypothetical_collations(), assign_list_collations(), assign_ordered_set_collations(), COLLATE_CONFLICT, COLLATE_EXPLICIT, COLLATE_IMPLICIT, COLLATE_NONE, assign_collations_context::collation, assign_collations_context::collation2, CollateExpr::collOid, context, CaseExpr::defresult, elog, ereport, errcode(), errhint(), errmsg(), ERROR, TargetEntry::expr, exprCollation(), expression_tree_walker, exprLocation(), exprSetCollation(), exprSetInputCollation(), exprType(), forboth, get_collation_name(), get_typcollation(), InvalidOid, lappend_oid(), RowCompareExpr::largs, lfirst, lfirst_node, linitial_node, list_make2, assign_collations_context::location, CollateExpr::location, assign_collations_context::location2, merge_collation_state(), NIL, nodeTag, OidIsValid, parser_errposition(), assign_collations_context::pstate, RowCompareExpr::rargs, SubscriptingRef::refassgnexpr, SubscriptingRef::refexpr, SubscriptingRef::reflowerindexpr, SubscriptingRef::refupperindexpr, CoerceToDomain::resulttype, select_common_collation(), assign_collations_context::strength, and Query::targetList.

Referenced by assign_aggregate_collations(), assign_expr_collations(), assign_hypothetical_collations(), assign_ordered_set_collations(), and select_common_collation().

assign_expr_collations()

void assign_expr_collations	(	ParseState *	pstate,
		Node *	expr
	)

Definition at line 177 of file parse_collate.c.

{
    assign_collations_context context;
 
    /* initialize context for tree walk */
    context.pstate = pstate;
    context.collation = InvalidOid;
    context.strength = COLLATE_NONE;
    context.location = -1;
 
    /* and away we go */
    (void) assign_collations_walker(expr, &context);
}

References assign_collations_walker(), COLLATE_NONE, context, and InvalidOid.

Referenced by AlterPolicy(), assign_aggregate_collations(), assign_collations_walker(), assign_list_collations(), assign_ordered_set_collations(), assign_query_collations_walker(), ATPrepAlterColumnType(), buildMergedJoinVar(), coerce_fn_result_column(), cookConstraint(), cookDefault(), CreatePolicy(), CreateTriggerFiringOn(), DoCopy(), domainAddCheckConstraint(), EvaluateParams(), interpret_function_parameter_list(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformCallStmt(), transformCaseExpr(), transformIndexStmt(), transformJsonTableColumns(), transformPartitionBoundValue(), transformPartitionSpec(), TransformPubWhereClauses(), transformRangeTableFunc(), transformRangeTableSample(), transformRuleStmt(), and transformStatsStmt().

assign_hypothetical_collations()

static void assign_hypothetical_collations ( Aggref *  aggref, assign_collations_context *  loccontext  )

static

Definition at line 955 of file parse_collate.c.

{
    ListCell   *h_cell = list_head(aggref->aggdirectargs);
    ListCell   *s_cell = list_head(aggref->args);
    bool        merge_sort_collations;
    int         extra_args;
 
    /* Merge sort collations to parent only if there can be only one */
    merge_sort_collations = (list_length(aggref->args) == 1 &&
                             get_func_variadictype(aggref->aggfnoid) == InvalidOid);
 
    /* Process any non-hypothetical direct args */
    extra_args = list_length(aggref->aggdirectargs) - list_length(aggref->args);
    Assert(extra_args >= 0);
    while (extra_args-- > 0)
    {
        (void) assign_collations_walker((Node *) lfirst(h_cell), loccontext);
        h_cell = lnext(aggref->aggdirectargs, h_cell);
    }
 
    /* Scan hypothetical args and aggregated args in parallel */
    while (h_cell && s_cell)
    {
        Node       *h_arg = (Node *) lfirst(h_cell);
        TargetEntry *s_tle = (TargetEntry *) lfirst(s_cell);
        assign_collations_context paircontext;
 
        /*
         * Assign collations internally in this pair of expressions, then
         * choose a common collation for them.  This should match
         * select_common_collation(), but we can't use that function as-is
         * because we need access to the whole collation state so we can
         * bubble it up to the aggregate function's level.
         */
        paircontext.pstate = loccontext->pstate;
        paircontext.collation = InvalidOid;
        paircontext.strength = COLLATE_NONE;
        paircontext.location = -1;
        /* Set these fields just to suppress uninitialized-value warnings: */
        paircontext.collation2 = InvalidOid;
        paircontext.location2 = -1;
 
        (void) assign_collations_walker(h_arg, &paircontext);
        (void) assign_collations_walker((Node *) s_tle->expr, &paircontext);
 
        /* deal with collation conflict */
        if (paircontext.strength == COLLATE_CONFLICT)
            ereport(ERROR,
                    (errcode(ERRCODE_COLLATION_MISMATCH),
                     errmsg("collation mismatch between implicit collations \"%s\" and \"%s\"",
                            get_collation_name(paircontext.collation),
                            get_collation_name(paircontext.collation2)),
                     errhint("You can choose the collation by applying the COLLATE clause to one or both expressions."),
                     parser_errposition(paircontext.pstate,
                                        paircontext.location2)));
 
        /*
         * At this point paircontext.collation can be InvalidOid only if the
         * type is not collatable; no need to do anything in that case.  If we
         * do have to change the sort column's collation, do it by inserting a
         * RelabelType node into the sort column TLE.
         *
         * XXX This is pretty grotty for a couple of reasons:
         * assign_collations_walker isn't supposed to be changing the
         * expression structure like this, and a parse-time change of
         * collation ought to be signaled by a CollateExpr not a RelabelType
         * (the use of RelabelType for collation marking is supposed to be a
         * planner/executor thing only).  But we have no better alternative.
         * In particular, injecting a CollateExpr could result in the
         * expression being interpreted differently after dump/reload, since
         * we might be effectively promoting an implicit collation to
         * explicit.  This kluge is relying on ruleutils.c not printing a
         * COLLATE clause for a RelabelType, and probably on some other
         * fragile behaviors.
         */
        if (OidIsValid(paircontext.collation) &&
            paircontext.collation != exprCollation((Node *) s_tle->expr))
        {
            s_tle->expr = (Expr *)
                makeRelabelType(s_tle->expr,
                                exprType((Node *) s_tle->expr),
                                exprTypmod((Node *) s_tle->expr),
                                paircontext.collation,
                                COERCE_IMPLICIT_CAST);
        }
 
        /*
         * If appropriate, merge this column's collation state up to the
         * aggregate function.
         */
        if (merge_sort_collations)
            merge_collation_state(paircontext.collation,
                                  paircontext.strength,
                                  paircontext.location,
                                  paircontext.collation2,
                                  paircontext.location2,
                                  loccontext);
 
        h_cell = lnext(aggref->aggdirectargs, h_cell);
        s_cell = lnext(aggref->args, s_cell);
    }
    Assert(h_cell == NULL && s_cell == NULL);
}

References Aggref::aggdirectargs, Aggref::aggfnoid, Aggref::args, Assert, assign_collations_walker(), COERCE_IMPLICIT_CAST, COLLATE_CONFLICT, COLLATE_NONE, assign_collations_context::collation, assign_collations_context::collation2, ereport, errcode(), errhint(), errmsg(), ERROR, TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), get_collation_name(), get_func_variadictype(), InvalidOid, lfirst, list_head(), list_length(), lnext(), assign_collations_context::location, assign_collations_context::location2, makeRelabelType(), merge_collation_state(), OidIsValid, parser_errposition(), assign_collations_context::pstate, and assign_collations_context::strength.

Referenced by assign_collations_walker().

assign_list_collations()

void assign_list_collations	(	ParseState *	pstate,
		List *	exprs
	)

Definition at line 155 of file parse_collate.c.

{
    ListCell   *lc;
 
    foreach(lc, exprs)
    {
        Node       *node = (Node *) lfirst(lc);
 
        assign_expr_collations(pstate, node);
    }
}

References assign_expr_collations(), and lfirst.

Referenced by assign_collations_walker(), assign_query_collations_walker(), and transformRangeFunction().

assign_ordered_set_collations()

static void assign_ordered_set_collations ( Aggref *  aggref, assign_collations_context *  loccontext  )

static

Definition at line 919 of file parse_collate.c.

{
    bool        merge_sort_collations;
    ListCell   *lc;
 
    /* Merge sort collations to parent only if there can be only one */
    merge_sort_collations = (list_length(aggref->args) == 1 &&
                             get_func_variadictype(aggref->aggfnoid) == InvalidOid);
 
    /* Direct args, if any, are normal children of the Aggref node */
    (void) assign_collations_walker((Node *) aggref->aggdirectargs,
                                    loccontext);
 
    /* Process aggregated args appropriately */
    foreach(lc, aggref->args)
    {
        TargetEntry *tle = lfirst_node(TargetEntry, lc);
 
        if (merge_sort_collations)
            (void) assign_collations_walker((Node *) tle, loccontext);
        else
            assign_expr_collations(loccontext->pstate, (Node *) tle);
    }
}

References Aggref::aggdirectargs, Aggref::aggfnoid, Aggref::args, assign_collations_walker(), assign_expr_collations(), get_func_variadictype(), InvalidOid, lfirst_node, list_length(), and assign_collations_context::pstate.

Referenced by assign_collations_walker().

assign_query_collations()

void assign_query_collations	(	ParseState *	pstate,
		Query *	query
	)

Definition at line 101 of file parse_collate.c.

{
    /*
     * We just use query_tree_walker() to visit all the contained expressions.
     * We can skip the rangetable and CTE subqueries, though, since RTEs and
     * subqueries had better have been processed already (else Vars referring
     * to them would not get created with the right collation).
     */
    (void) query_tree_walker(query,
                             assign_query_collations_walker,
                             pstate,
                             QTW_IGNORE_RANGE_TABLE |
                             QTW_IGNORE_CTE_SUBQUERIES);
}

References assign_query_collations_walker(), QTW_IGNORE_CTE_SUBQUERIES, QTW_IGNORE_RANGE_TABLE, and query_tree_walker.

Referenced by transformDeleteStmt(), transformMergeStmt(), transformPLAssignStmt(), transformReturnStmt(), transformSelectStmt(), transformSetOperationStmt(), transformUpdateStmt(), and transformValuesClause().

assign_query_collations_walker()

static bool assign_query_collations_walker ( Node *  node, ParseState *  pstate  )

static

Definition at line 126 of file parse_collate.c.

{
    /* Need do nothing for empty subexpressions */
    if (node == NULL)
        return false;
 
    /*
     * We don't want to recurse into a set-operations tree; it's already been
     * fully processed in transformSetOperationStmt.
     */
    if (IsA(node, SetOperationStmt))
        return false;
 
    if (IsA(node, List))
        assign_list_collations(pstate, (List *) node);
    else
        assign_expr_collations(pstate, node);
 
    return false;
}

References assign_expr_collations(), assign_list_collations(), and IsA.

Referenced by assign_query_collations().

merge_collation_state()

static void merge_collation_state ( Oid  collation, CollateStrength  strength, int  location, Oid  collation2, int  location2, assign_collations_context *  context  )

static

Definition at line 780 of file parse_collate.c.

{
    /*
     * If the collation strength for this node is different from what's
     * already in *context, then this node either dominates or is dominated by
     * earlier siblings.
     */
    if (strength > context->strength)
    {
        /* Override previous parent state */
        context->collation = collation;
        context->strength = strength;
        context->location = location;
        /* Bubble up error info if applicable */
        if (strength == COLLATE_CONFLICT)
        {
            context->collation2 = collation2;
            context->location2 = location2;
        }
    }
    else if (strength == context->strength)
    {
        /* Merge, or detect error if there's a collation conflict */
        switch (strength)
        {
            case COLLATE_NONE:
                /* Nothing + nothing is still nothing */
                break;
            case COLLATE_IMPLICIT:
                if (collation != context->collation)
                {
                    /*
                     * Non-default implicit collation always beats default.
                     */
                    if (context->collation == DEFAULT_COLLATION_OID)
                    {
                        /* Override previous parent state */
                        context->collation = collation;
                        context->strength = strength;
                        context->location = location;
                    }
                    else if (collation != DEFAULT_COLLATION_OID)
                    {
                        /*
                         * Oops, we have a conflict.  We cannot throw error
                         * here, since the conflict could be resolved by a
                         * later sibling CollateExpr, or the parent might not
                         * care about collation anyway.  Return enough info to
                         * throw the error later, if needed.
                         */
                        context->strength = COLLATE_CONFLICT;
                        context->collation2 = collation;
                        context->location2 = location;
                    }
                }
                break;
            case COLLATE_CONFLICT:
                /* We're still conflicted ... */
                break;
            case COLLATE_EXPLICIT:
                if (collation != context->collation)
                {
                    /*
                     * Oops, we have a conflict of explicit COLLATE clauses.
                     * Here we choose to throw error immediately; that is what
                     * the SQL standard says to do, and there's no good reason
                     * to be less strict.
                     */
                    ereport(ERROR,
                            (errcode(ERRCODE_COLLATION_MISMATCH),
                             errmsg("collation mismatch between explicit collations \"%s\" and \"%s\"",
                                    get_collation_name(context->collation),
                                    get_collation_name(collation)),
                             parser_errposition(context->pstate, location)));
                }
                break;
        }
    }
}

References COLLATE_CONFLICT, COLLATE_EXPLICIT, COLLATE_IMPLICIT, COLLATE_NONE, context, ereport, errcode(), errmsg(), ERROR, get_collation_name(), and parser_errposition().

Referenced by assign_collations_walker(), and assign_hypothetical_collations().

select_common_collation()

Oid select_common_collation	(	ParseState *	pstate,
		List *	exprs,
		bool	none_ok
	)

Definition at line 208 of file parse_collate.c.

{
    assign_collations_context context;
 
    /* initialize context for tree walk */
    context.pstate = pstate;
    context.collation = InvalidOid;
    context.strength = COLLATE_NONE;
    context.location = -1;
 
    /* and away we go */
    (void) assign_collations_walker((Node *) exprs, &context);
 
    /* deal with collation conflict */
    if (context.strength == COLLATE_CONFLICT)
    {
        if (none_ok)
            return InvalidOid;
        ereport(ERROR,
                (errcode(ERRCODE_COLLATION_MISMATCH),
                 errmsg("collation mismatch between implicit collations \"%s\" and \"%s\"",
                        get_collation_name(context.collation),
                        get_collation_name(context.collation2)),
                 errhint("You can choose the collation by applying the COLLATE clause to one or both expressions."),
                 parser_errposition(context.pstate, context.location2)));
    }
 
    /*
     * Note: if strength is still COLLATE_NONE, we'll return InvalidOid, but
     * that's okay because it must mean none of the expressions returned
     * collatable datatypes.
     */
    return context.collation;
}

References assign_collations_walker(), COLLATE_CONFLICT, COLLATE_NONE, context, ereport, errcode(), errhint(), errmsg(), ERROR, get_collation_name(), InvalidOid, and parser_errposition().

Referenced by analyzeCTE(), assign_collations_walker(), transformSetOperationTree(), and transformValuesClause().