Remove vestigial resolveUnknown arguments from transformSortClause etc.

There's really no situation where we don't want these unknown-to-text
conversions to happen.  The alternative is failure anyway, and the one
caller that was passing "false" did so only because it expected the
case could not arise.  Might as well simplify the code.

Discussion: https://postgr.es/m/CAH2L28uwwbL9HUM-WR=hromW1Cvamkn7O-g8fPY2m=_7muJ0oA@mail.gmail.com

diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c
index f954dc15f0e3983297831f6259a645279640460d..0f7659bb6be5ebfc909ac28682cf68fde6d4070a 100644 (file)
--- a/src/backend/parser/analyze.c
+++ b/src/backend/parser/analyze.c
@@ -1232,7 +1232,6 @@ transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
                                                                                  stmt->sortClause,
                                                                                  &qry->targetList,
                                                                                  EXPR_KIND_ORDER_BY,
-                                                                                 true /* fix unknowns */ ,
                                                                                  false /* allow SQL92 rules */ );
 
        qry->groupClause = transformGroupClause(pstate,
@@ -1512,7 +1511,6 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt)
                                                                                  stmt->sortClause,
                                                                                  &qry->targetList,
                                                                                  EXPR_KIND_ORDER_BY,
-                                                                                 true /* fix unknowns */ ,
                                                                                  false /* allow SQL92 rules */ );
 
        qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
@@ -1736,7 +1734,6 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
                                                                                  sortClause,
                                                                                  &qry->targetList,
                                                                                  EXPR_KIND_ORDER_BY,
-                                                                                 false /* no unknowns expected */ ,
                                                                                  false /* allow SQL92 rules */ );
 
        /* restore namespace, remove jrte from rtable */

diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c
index 7be7fe96892e3b4370e3a2d17246d140e0ea8baf..efe1c371efc205f7b87c63fb1da07c2313cfdb96 100644 (file)
--- a/src/backend/parser/parse_agg.c
+++ b/src/backend/parser/parse_agg.c
@@ -155,8 +155,7 @@ transformAggregateCall(ParseState *pstate, Aggref *agg,
                        tlist = lappend(tlist, tle);
 
                        torder = addTargetToSortList(pstate, tle,
-                                                                                torder, tlist, sortby,
-                                                                                true /* fix unknowns */ );
+                                                                                torder, tlist, sortby);
                }
 
                /* Never any DISTINCT in an ordered-set agg */
@@ -196,7 +195,6 @@ transformAggregateCall(ParseState *pstate, Aggref *agg,
                                                                         aggorder,
                                                                         &tlist,
                                                                         EXPR_KIND_ORDER_BY,
-                                                                        true /* fix unknowns */ ,
                                                                         true /* force SQL99 rules */ );
 
                /*

diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c
index 4769e786202d7558c69467c4a40aef20c07d962e..69f47364388809e78855e5c093e0a5a92b53e545 100644 (file)
--- a/src/backend/parser/parse_clause.c
+++ b/src/backend/parser/parse_clause.c
@@ -89,8 +89,7 @@ static int get_matching_location(int sortgroupref,
 static List *resolve_unique_index_expr(ParseState *pstate, InferClause *infer,
                                                  Relation heapRel);
 static List *addTargetToGroupList(ParseState *pstate, TargetEntry *tle,
-                                        List *grouplist, List *targetlist, int location,
-                                        bool resolveUnknown);
+                                        List *grouplist, List *targetlist, int location);
 static WindowClause *findWindowClause(List *wclist, const char *name);
 static Node *transformFrameOffset(ParseState *pstate, int frameOptions,
                                         Node *clause);
@@ -2011,8 +2010,7 @@ transformGroupClauseExpr(List **flatresult, Bitmapset *seen_local,
        if (!found)
                *flatresult = addTargetToGroupList(pstate, tle,
                                                                                   *flatresult, *targetlist,
-                                                                                  exprLocation(gexpr),
-                                                                                  true);
+                                                                                  exprLocation(gexpr));
 
        /*
         * _something_ must have assigned us a sortgroupref by now...
@@ -2300,7 +2298,6 @@ transformSortClause(ParseState *pstate,
                                        List *orderlist,
                                        List **targetlist,
                                        ParseExprKind exprKind,
-                                       bool resolveUnknown,
                                        bool useSQL99)
 {
        List       *sortlist = NIL;
@@ -2319,8 +2316,7 @@ transformSortClause(ParseState *pstate,
                                                                                   targetlist, exprKind);
 
                sortlist = addTargetToSortList(pstate, tle,
-                                                                          sortlist, *targetlist, sortby,
-                                                                          resolveUnknown);
+                                                                          sortlist, *targetlist, sortby);
        }
 
        return sortlist;
@@ -2382,7 +2378,6 @@ transformWindowDefinitions(ParseState *pstate,
                                                                                  windef->orderClause,
                                                                                  targetlist,
                                                                                  EXPR_KIND_WINDOW_ORDER,
-                                                                                 true /* fix unknowns */ ,
                                                                                  true /* force SQL99 rules */ );
                partitionClause = transformGroupClause(pstate,
                                                                                           windef->partitionClause,
@@ -2553,8 +2548,7 @@ transformDistinctClause(ParseState *pstate,
                        continue;                       /* ignore junk */
                result = addTargetToGroupList(pstate, tle,
                                                                          result, *targetlist,
-                                                                         exprLocation((Node *) tle->expr),
-                                                                         true);
+                                                                         exprLocation((Node *) tle->expr));
        }
 
        /*
@@ -2671,8 +2665,7 @@ transformDistinctOnClause(ParseState *pstate, List *distinctlist,
                                         parser_errposition(pstate, exprLocation(dexpr))));
                result = addTargetToGroupList(pstate, tle,
                                                                          result, *targetlist,
-                                                                         exprLocation(dexpr),
-                                                                         true);
+                                                                         exprLocation(dexpr));
        }
 
        /*
@@ -2906,17 +2899,11 @@ transformOnConflictArbiter(ParseState *pstate,
  *             list, add it to the end of the list, using the given sort ordering
  *             info.
  *
- * If resolveUnknown is TRUE, convert TLEs of type UNKNOWN to TEXT.  If not,
- * do nothing (which implies the search for a sort operator will fail).
- * pstate should be provided if resolveUnknown is TRUE, but can be NULL
- * otherwise.
- *
  * Returns the updated SortGroupClause list.
  */
 List *
 addTargetToSortList(ParseState *pstate, TargetEntry *tle,
-                                       List *sortlist, List *targetlist, SortBy *sortby,
-                                       bool resolveUnknown)
+                                       List *sortlist, List *targetlist, SortBy *sortby)
 {
        Oid                     restype = exprType((Node *) tle->expr);
        Oid                     sortop;
@@ -2927,7 +2914,7 @@ addTargetToSortList(ParseState *pstate, TargetEntry *tle,
        ParseCallbackState pcbstate;
 
        /* if tlist item is an UNKNOWN literal, change it to TEXT */
-       if (restype == UNKNOWNOID && resolveUnknown)
+       if (restype == UNKNOWNOID)
        {
                tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr,
                                                                                 restype, TEXTOID, -1,
@@ -3055,22 +3042,16 @@ addTargetToSortList(ParseState *pstate, TargetEntry *tle,
  * to a SELECT item that matches the GROUP BY item; it'd be pretty confusing
  * to report such a location.
  *
- * If resolveUnknown is TRUE, convert TLEs of type UNKNOWN to TEXT.  If not,
- * do nothing (which implies the search for an equality operator will fail).
- * pstate should be provided if resolveUnknown is TRUE, but can be NULL
- * otherwise.
- *
  * Returns the updated SortGroupClause list.
  */
 static List *
 addTargetToGroupList(ParseState *pstate, TargetEntry *tle,
-                                        List *grouplist, List *targetlist, int location,
-                                        bool resolveUnknown)
+                                        List *grouplist, List *targetlist, int location)
 {
        Oid                     restype = exprType((Node *) tle->expr);
 
        /* if tlist item is an UNKNOWN literal, change it to TEXT */
-       if (restype == UNKNOWNOID && resolveUnknown)
+       if (restype == UNKNOWNOID)
        {
                tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr,
                                                                                 restype, TEXTOID, -1,

diff --git a/src/include/parser/parse_clause.h b/src/include/parser/parse_clause.h
index 3cdb261343ce00a7b369f4d5ef80ea38e21a1585..823138f6c0e04c79817cd406bde37afb14dc7921 100644 (file)
--- a/src/include/parser/parse_clause.h
+++ b/src/include/parser/parse_clause.h
@@ -31,7 +31,7 @@ extern List *transformGroupClause(ParseState *pstate, List *grouplist,
                                         ParseExprKind exprKind, bool useSQL99);
 extern List *transformSortClause(ParseState *pstate, List *orderlist,
                                        List **targetlist, ParseExprKind exprKind,
-                                       bool resolveUnknown, bool useSQL99);
+                                       bool useSQL99);
 
 extern List *transformWindowDefinitions(ParseState *pstate,
                                                   List *windowdefs,
@@ -47,8 +47,7 @@ extern void transformOnConflictArbiter(ParseState *pstate,
                                                   Oid *constraint);
 
 extern List *addTargetToSortList(ParseState *pstate, TargetEntry *tle,
-                                       List *sortlist, List *targetlist, SortBy *sortby,
-                                       bool resolveUnknown);
+                                       List *sortlist, List *targetlist, SortBy *sortby);
 extern Index assignSortGroupRef(TargetEntry *tle, List *tlist);
 extern bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList);