LCOV - code coverage report
Current view: top level - src/backend/utils/adt - like_support.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 462 557 82.9 %
Date: 2024-09-16 12:11:48 Functions: 33 41 80.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * like_support.c
       4             :  *    Planner support functions for LIKE, regex, and related operators.
       5             :  *
       6             :  * These routines handle special optimization of operators that can be
       7             :  * used with index scans even though they are not known to the executor's
       8             :  * indexscan machinery.  The key idea is that these operators allow us
       9             :  * to derive approximate indexscan qual clauses, such that any tuples
      10             :  * that pass the operator clause itself must also satisfy the simpler
      11             :  * indexscan condition(s).  Then we can use the indexscan machinery
      12             :  * to avoid scanning as much of the table as we'd otherwise have to,
      13             :  * while applying the original operator as a qpqual condition to ensure
      14             :  * we deliver only the tuples we want.  (In essence, we're using a regular
      15             :  * index as if it were a lossy index.)
      16             :  *
      17             :  * An example of what we're doing is
      18             :  *          textfield LIKE 'abc%def'
      19             :  * from which we can generate the indexscanable conditions
      20             :  *          textfield >= 'abc' AND textfield < 'abd'
      21             :  * which allow efficient scanning of an index on textfield.
      22             :  * (In reality, character set and collation issues make the transformation
      23             :  * from LIKE to indexscan limits rather harder than one might think ...
      24             :  * but that's the basic idea.)
      25             :  *
      26             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      27             :  * Portions Copyright (c) 1994, Regents of the University of California
      28             :  *
      29             :  *
      30             :  * IDENTIFICATION
      31             :  *    src/backend/utils/adt/like_support.c
      32             :  *
      33             :  *-------------------------------------------------------------------------
      34             :  */
      35             : #include "postgres.h"
      36             : 
      37             : #include <math.h>
      38             : 
      39             : #include "access/htup_details.h"
      40             : #include "catalog/pg_collation.h"
      41             : #include "catalog/pg_operator.h"
      42             : #include "catalog/pg_opfamily.h"
      43             : #include "catalog/pg_statistic.h"
      44             : #include "catalog/pg_type.h"
      45             : #include "mb/pg_wchar.h"
      46             : #include "miscadmin.h"
      47             : #include "nodes/makefuncs.h"
      48             : #include "nodes/nodeFuncs.h"
      49             : #include "nodes/supportnodes.h"
      50             : #include "utils/builtins.h"
      51             : #include "utils/datum.h"
      52             : #include "utils/lsyscache.h"
      53             : #include "utils/pg_locale.h"
      54             : #include "utils/selfuncs.h"
      55             : #include "utils/varlena.h"
      56             : 
      57             : 
      58             : typedef enum
      59             : {
      60             :     Pattern_Type_Like,
      61             :     Pattern_Type_Like_IC,
      62             :     Pattern_Type_Regex,
      63             :     Pattern_Type_Regex_IC,
      64             :     Pattern_Type_Prefix,
      65             : } Pattern_Type;
      66             : 
      67             : typedef enum
      68             : {
      69             :     Pattern_Prefix_None, Pattern_Prefix_Partial, Pattern_Prefix_Exact,
      70             : } Pattern_Prefix_Status;
      71             : 
      72             : static Node *like_regex_support(Node *rawreq, Pattern_Type ptype);
      73             : static List *match_pattern_prefix(Node *leftop,
      74             :                                   Node *rightop,
      75             :                                   Pattern_Type ptype,
      76             :                                   Oid expr_coll,
      77             :                                   Oid opfamily,
      78             :                                   Oid indexcollation);
      79             : static double patternsel_common(PlannerInfo *root,
      80             :                                 Oid oprid,
      81             :                                 Oid opfuncid,
      82             :                                 List *args,
      83             :                                 int varRelid,
      84             :                                 Oid collation,
      85             :                                 Pattern_Type ptype,
      86             :                                 bool negate);
      87             : static Pattern_Prefix_Status pattern_fixed_prefix(Const *patt,
      88             :                                                   Pattern_Type ptype,
      89             :                                                   Oid collation,
      90             :                                                   Const **prefix,
      91             :                                                   Selectivity *rest_selec);
      92             : static Selectivity prefix_selectivity(PlannerInfo *root,
      93             :                                       VariableStatData *vardata,
      94             :                                       Oid eqopr, Oid ltopr, Oid geopr,
      95             :                                       Oid collation,
      96             :                                       Const *prefixcon);
      97             : static Selectivity like_selectivity(const char *patt, int pattlen,
      98             :                                     bool case_insensitive);
      99             : static Selectivity regex_selectivity(const char *patt, int pattlen,
     100             :                                      bool case_insensitive,
     101             :                                      int fixed_prefix_len);
     102             : static int  pattern_char_isalpha(char c, bool is_multibyte,
     103             :                                  pg_locale_t locale);
     104             : static Const *make_greater_string(const Const *str_const, FmgrInfo *ltproc,
     105             :                                   Oid collation);
     106             : static Datum string_to_datum(const char *str, Oid datatype);
     107             : static Const *string_to_const(const char *str, Oid datatype);
     108             : static Const *string_to_bytea_const(const char *str, size_t str_len);
     109             : 
     110             : 
     111             : /*
     112             :  * Planner support functions for LIKE, regex, and related operators
     113             :  */
     114             : Datum
     115        5126 : textlike_support(PG_FUNCTION_ARGS)
     116             : {
     117        5126 :     Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
     118             : 
     119        5126 :     PG_RETURN_POINTER(like_regex_support(rawreq, Pattern_Type_Like));
     120             : }
     121             : 
     122             : Datum
     123         358 : texticlike_support(PG_FUNCTION_ARGS)
     124             : {
     125         358 :     Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
     126             : 
     127         358 :     PG_RETURN_POINTER(like_regex_support(rawreq, Pattern_Type_Like_IC));
     128             : }
     129             : 
     130             : Datum
     131       20122 : textregexeq_support(PG_FUNCTION_ARGS)
     132             : {
     133       20122 :     Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
     134             : 
     135       20122 :     PG_RETURN_POINTER(like_regex_support(rawreq, Pattern_Type_Regex));
     136             : }
     137             : 
     138             : Datum
     139         118 : texticregexeq_support(PG_FUNCTION_ARGS)
     140             : {
     141         118 :     Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
     142             : 
     143         118 :     PG_RETURN_POINTER(like_regex_support(rawreq, Pattern_Type_Regex_IC));
     144             : }
     145             : 
     146             : Datum
     147         156 : text_starts_with_support(PG_FUNCTION_ARGS)
     148             : {
     149         156 :     Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
     150             : 
     151         156 :     PG_RETURN_POINTER(like_regex_support(rawreq, Pattern_Type_Prefix));
     152             : }
     153             : 
     154             : /* Common code for the above */
     155             : static Node *
     156       25880 : like_regex_support(Node *rawreq, Pattern_Type ptype)
     157             : {
     158       25880 :     Node       *ret = NULL;
     159             : 
     160       25880 :     if (IsA(rawreq, SupportRequestSelectivity))
     161             :     {
     162             :         /*
     163             :          * Make a selectivity estimate for a function call, just as we'd do if
     164             :          * the call was via the corresponding operator.
     165             :          */
     166          24 :         SupportRequestSelectivity *req = (SupportRequestSelectivity *) rawreq;
     167             :         Selectivity s1;
     168             : 
     169          24 :         if (req->is_join)
     170             :         {
     171             :             /*
     172             :              * For the moment we just punt.  If patternjoinsel is ever
     173             :              * improved to do better, this should be made to call it.
     174             :              */
     175           0 :             s1 = DEFAULT_MATCH_SEL;
     176             :         }
     177             :         else
     178             :         {
     179             :             /* Share code with operator restriction selectivity functions */
     180          24 :             s1 = patternsel_common(req->root,
     181             :                                    InvalidOid,
     182             :                                    req->funcid,
     183             :                                    req->args,
     184             :                                    req->varRelid,
     185             :                                    req->inputcollid,
     186             :                                    ptype,
     187             :                                    false);
     188             :         }
     189          24 :         req->selectivity = s1;
     190          24 :         ret = (Node *) req;
     191             :     }
     192       25856 :     else if (IsA(rawreq, SupportRequestIndexCondition))
     193             :     {
     194             :         /* Try to convert operator/function call to index conditions */
     195        7276 :         SupportRequestIndexCondition *req = (SupportRequestIndexCondition *) rawreq;
     196             : 
     197             :         /*
     198             :          * Currently we have no "reverse" match operators with the pattern on
     199             :          * the left, so we only need consider cases with the indexkey on the
     200             :          * left.
     201             :          */
     202        7276 :         if (req->indexarg != 0)
     203           0 :             return NULL;
     204             : 
     205        7276 :         if (is_opclause(req->node))
     206             :         {
     207        7252 :             OpExpr     *clause = (OpExpr *) req->node;
     208             : 
     209             :             Assert(list_length(clause->args) == 2);
     210             :             ret = (Node *)
     211        7252 :                 match_pattern_prefix((Node *) linitial(clause->args),
     212        7252 :                                      (Node *) lsecond(clause->args),
     213             :                                      ptype,
     214             :                                      clause->inputcollid,
     215             :                                      req->opfamily,
     216             :                                      req->indexcollation);
     217             :         }
     218          24 :         else if (is_funcclause(req->node))   /* be paranoid */
     219             :         {
     220          24 :             FuncExpr   *clause = (FuncExpr *) req->node;
     221             : 
     222             :             Assert(list_length(clause->args) == 2);
     223             :             ret = (Node *)
     224          24 :                 match_pattern_prefix((Node *) linitial(clause->args),
     225          24 :                                      (Node *) lsecond(clause->args),
     226             :                                      ptype,
     227             :                                      clause->inputcollid,
     228             :                                      req->opfamily,
     229             :                                      req->indexcollation);
     230             :         }
     231             :     }
     232             : 
     233       25880 :     return ret;
     234             : }
     235             : 
     236             : /*
     237             :  * match_pattern_prefix
     238             :  *    Try to generate an indexqual for a LIKE or regex operator.
     239             :  */
     240             : static List *
     241        7276 : match_pattern_prefix(Node *leftop,
     242             :                      Node *rightop,
     243             :                      Pattern_Type ptype,
     244             :                      Oid expr_coll,
     245             :                      Oid opfamily,
     246             :                      Oid indexcollation)
     247             : {
     248             :     List       *result;
     249             :     Const      *patt;
     250             :     Const      *prefix;
     251             :     Pattern_Prefix_Status pstatus;
     252             :     Oid         ldatatype;
     253             :     Oid         rdatatype;
     254             :     Oid         eqopr;
     255             :     Oid         ltopr;
     256             :     Oid         geopr;
     257        7276 :     Oid         preopr = InvalidOid;
     258             :     bool        collation_aware;
     259             :     Expr       *expr;
     260             :     FmgrInfo    ltproc;
     261             :     Const      *greaterstr;
     262             : 
     263             :     /*
     264             :      * Can't do anything with a non-constant or NULL pattern argument.
     265             :      *
     266             :      * Note that since we restrict ourselves to cases with a hard constant on
     267             :      * the RHS, it's a-fortiori a pseudoconstant, and we don't need to worry
     268             :      * about verifying that.
     269             :      */
     270        7276 :     if (!IsA(rightop, Const) ||
     271        7156 :         ((Const *) rightop)->constisnull)
     272         120 :         return NIL;
     273        7156 :     patt = (Const *) rightop;
     274             : 
     275             :     /*
     276             :      * Not supported if the expression collation is nondeterministic.  The
     277             :      * optimized equality or prefix tests use bytewise comparisons, which is
     278             :      * not consistent with nondeterministic collations.  The actual
     279             :      * pattern-matching implementation functions will later error out that
     280             :      * pattern-matching is not supported with nondeterministic collations. (We
     281             :      * could also error out here, but by doing it later we get more precise
     282             :      * error messages.)  (It should be possible to support at least
     283             :      * Pattern_Prefix_Exact, but no point as long as the actual
     284             :      * pattern-matching implementations don't support it.)
     285             :      *
     286             :      * expr_coll is not set for a non-collation-aware data type such as bytea.
     287             :      */
     288        7156 :     if (expr_coll && !get_collation_isdeterministic(expr_coll))
     289          12 :         return NIL;
     290             : 
     291             :     /*
     292             :      * Try to extract a fixed prefix from the pattern.
     293             :      */
     294        7144 :     pstatus = pattern_fixed_prefix(patt, ptype, expr_coll,
     295             :                                    &prefix, NULL);
     296             : 
     297             :     /* fail if no fixed prefix */
     298        7144 :     if (pstatus == Pattern_Prefix_None)
     299         306 :         return NIL;
     300             : 
     301             :     /*
     302             :      * Identify the operators we want to use, based on the type of the
     303             :      * left-hand argument.  Usually these are just the type's regular
     304             :      * comparison operators, but if we are considering one of the semi-legacy
     305             :      * "pattern" opclasses, use the "pattern" operators instead.  Those are
     306             :      * not collation-sensitive but always use C collation, as we want.  The
     307             :      * selected operators also determine the needed type of the prefix
     308             :      * constant.
     309             :      */
     310        6838 :     ldatatype = exprType(leftop);
     311        6838 :     switch (ldatatype)
     312             :     {
     313          68 :         case TEXTOID:
     314          68 :             if (opfamily == TEXT_PATTERN_BTREE_FAM_OID)
     315             :             {
     316           0 :                 eqopr = TextEqualOperator;
     317           0 :                 ltopr = TextPatternLessOperator;
     318           0 :                 geopr = TextPatternGreaterEqualOperator;
     319           0 :                 collation_aware = false;
     320             :             }
     321          68 :             else if (opfamily == TEXT_SPGIST_FAM_OID)
     322             :             {
     323          24 :                 eqopr = TextEqualOperator;
     324          24 :                 ltopr = TextPatternLessOperator;
     325          24 :                 geopr = TextPatternGreaterEqualOperator;
     326             :                 /* This opfamily has direct support for prefixing */
     327          24 :                 preopr = TextPrefixOperator;
     328          24 :                 collation_aware = false;
     329             :             }
     330             :             else
     331             :             {
     332          44 :                 eqopr = TextEqualOperator;
     333          44 :                 ltopr = TextLessOperator;
     334          44 :                 geopr = TextGreaterEqualOperator;
     335          44 :                 collation_aware = true;
     336             :             }
     337          68 :             rdatatype = TEXTOID;
     338          68 :             break;
     339        6746 :         case NAMEOID:
     340             : 
     341             :             /*
     342             :              * Note that here, we need the RHS type to be text, so that the
     343             :              * comparison value isn't improperly truncated to NAMEDATALEN.
     344             :              */
     345        6746 :             eqopr = NameEqualTextOperator;
     346        6746 :             ltopr = NameLessTextOperator;
     347        6746 :             geopr = NameGreaterEqualTextOperator;
     348        6746 :             collation_aware = true;
     349        6746 :             rdatatype = TEXTOID;
     350        6746 :             break;
     351          24 :         case BPCHAROID:
     352          24 :             if (opfamily == BPCHAR_PATTERN_BTREE_FAM_OID)
     353             :             {
     354           0 :                 eqopr = BpcharEqualOperator;
     355           0 :                 ltopr = BpcharPatternLessOperator;
     356           0 :                 geopr = BpcharPatternGreaterEqualOperator;
     357           0 :                 collation_aware = false;
     358             :             }
     359             :             else
     360             :             {
     361          24 :                 eqopr = BpcharEqualOperator;
     362          24 :                 ltopr = BpcharLessOperator;
     363          24 :                 geopr = BpcharGreaterEqualOperator;
     364          24 :                 collation_aware = true;
     365             :             }
     366          24 :             rdatatype = BPCHAROID;
     367          24 :             break;
     368           0 :         case BYTEAOID:
     369           0 :             eqopr = ByteaEqualOperator;
     370           0 :             ltopr = ByteaLessOperator;
     371           0 :             geopr = ByteaGreaterEqualOperator;
     372           0 :             collation_aware = false;
     373           0 :             rdatatype = BYTEAOID;
     374           0 :             break;
     375           0 :         default:
     376             :             /* Can't get here unless we're attached to the wrong operator */
     377           0 :             return NIL;
     378             :     }
     379             : 
     380             :     /*
     381             :      * If necessary, coerce the prefix constant to the right type.  The given
     382             :      * prefix constant is either text or bytea type, therefore the only case
     383             :      * where we need to do anything is when converting text to bpchar.  Those
     384             :      * two types are binary-compatible, so relabeling the Const node is
     385             :      * sufficient.
     386             :      */
     387        6838 :     if (prefix->consttype != rdatatype)
     388             :     {
     389             :         Assert(prefix->consttype == TEXTOID &&
     390             :                rdatatype == BPCHAROID);
     391          24 :         prefix->consttype = rdatatype;
     392             :     }
     393             : 
     394             :     /*
     395             :      * If we found an exact-match pattern, generate an "=" indexqual.
     396             :      *
     397             :      * Here and below, check to see whether the desired operator is actually
     398             :      * supported by the index opclass, and fail quietly if not.  This allows
     399             :      * us to not be concerned with specific opclasses (except for the legacy
     400             :      * "pattern" cases); any index that correctly implements the operators
     401             :      * will work.
     402             :      */
     403        6838 :     if (pstatus == Pattern_Prefix_Exact)
     404             :     {
     405        5588 :         if (!op_in_opfamily(eqopr, opfamily))
     406          12 :             return NIL;
     407        5576 :         expr = make_opclause(eqopr, BOOLOID, false,
     408             :                              (Expr *) leftop, (Expr *) prefix,
     409             :                              InvalidOid, indexcollation);
     410        5576 :         result = list_make1(expr);
     411        5576 :         return result;
     412             :     }
     413             : 
     414             :     /*
     415             :      * Otherwise, we have a nonempty required prefix of the values.  Some
     416             :      * opclasses support prefix checks directly, otherwise we'll try to
     417             :      * generate a range constraint.
     418             :      */
     419        1250 :     if (OidIsValid(preopr) && op_in_opfamily(preopr, opfamily))
     420             :     {
     421          24 :         expr = make_opclause(preopr, BOOLOID, false,
     422             :                              (Expr *) leftop, (Expr *) prefix,
     423             :                              InvalidOid, indexcollation);
     424          24 :         result = list_make1(expr);
     425          24 :         return result;
     426             :     }
     427             : 
     428             :     /*
     429             :      * Since we need a range constraint, it's only going to work reliably if
     430             :      * the index is collation-insensitive or has "C" collation.  Note that
     431             :      * here we are looking at the index's collation, not the expression's
     432             :      * collation -- this test is *not* dependent on the LIKE/regex operator's
     433             :      * collation.
     434             :      */
     435        1226 :     if (collation_aware &&
     436        1226 :         !pg_newlocale_from_collation(indexcollation)->collate_is_c)
     437           8 :         return NIL;
     438             : 
     439             :     /*
     440             :      * We can always say "x >= prefix".
     441             :      */
     442        1218 :     if (!op_in_opfamily(geopr, opfamily))
     443          12 :         return NIL;
     444        1206 :     expr = make_opclause(geopr, BOOLOID, false,
     445             :                          (Expr *) leftop, (Expr *) prefix,
     446             :                          InvalidOid, indexcollation);
     447        1206 :     result = list_make1(expr);
     448             : 
     449             :     /*-------
     450             :      * If we can create a string larger than the prefix, we can say
     451             :      * "x < greaterstr".  NB: we rely on make_greater_string() to generate
     452             :      * a guaranteed-greater string, not just a probably-greater string.
     453             :      * In general this is only guaranteed in C locale, so we'd better be
     454             :      * using a C-locale index collation.
     455             :      *-------
     456             :      */
     457        1206 :     if (!op_in_opfamily(ltopr, opfamily))
     458           0 :         return result;
     459        1206 :     fmgr_info(get_opcode(ltopr), &ltproc);
     460        1206 :     greaterstr = make_greater_string(prefix, &ltproc, indexcollation);
     461        1206 :     if (greaterstr)
     462             :     {
     463        1206 :         expr = make_opclause(ltopr, BOOLOID, false,
     464             :                              (Expr *) leftop, (Expr *) greaterstr,
     465             :                              InvalidOid, indexcollation);
     466        1206 :         result = lappend(result, expr);
     467             :     }
     468             : 
     469        1206 :     return result;
     470             : }
     471             : 
     472             : 
     473             : /*
     474             :  * patternsel_common - generic code for pattern-match restriction selectivity.
     475             :  *
     476             :  * To support using this from either the operator or function paths, caller
     477             :  * may pass either operator OID or underlying function OID; we look up the
     478             :  * latter from the former if needed.  (We could just have patternsel() call
     479             :  * get_opcode(), but the work would be wasted if we don't have a need to
     480             :  * compare a fixed prefix to the pg_statistic data.)
     481             :  *
     482             :  * Note that oprid and/or opfuncid should be for the positive-match operator
     483             :  * even when negate is true.
     484             :  */
     485             : static double
     486       10038 : patternsel_common(PlannerInfo *root,
     487             :                   Oid oprid,
     488             :                   Oid opfuncid,
     489             :                   List *args,
     490             :                   int varRelid,
     491             :                   Oid collation,
     492             :                   Pattern_Type ptype,
     493             :                   bool negate)
     494             : {
     495             :     VariableStatData vardata;
     496             :     Node       *other;
     497             :     bool        varonleft;
     498             :     Datum       constval;
     499             :     Oid         consttype;
     500             :     Oid         vartype;
     501             :     Oid         rdatatype;
     502             :     Oid         eqopr;
     503             :     Oid         ltopr;
     504             :     Oid         geopr;
     505             :     Pattern_Prefix_Status pstatus;
     506             :     Const      *patt;
     507       10038 :     Const      *prefix = NULL;
     508       10038 :     Selectivity rest_selec = 0;
     509       10038 :     double      nullfrac = 0.0;
     510             :     double      result;
     511             : 
     512             :     /*
     513             :      * Initialize result to the appropriate default estimate depending on
     514             :      * whether it's a match or not-match operator.
     515             :      */
     516       10038 :     if (negate)
     517        1576 :         result = 1.0 - DEFAULT_MATCH_SEL;
     518             :     else
     519        8462 :         result = DEFAULT_MATCH_SEL;
     520             : 
     521             :     /*
     522             :      * If expression is not variable op constant, then punt and return the
     523             :      * default estimate.
     524             :      */
     525       10038 :     if (!get_restriction_variable(root, args, varRelid,
     526             :                                   &vardata, &other, &varonleft))
     527         256 :         return result;
     528        9782 :     if (!varonleft || !IsA(other, Const))
     529             :     {
     530          50 :         ReleaseVariableStats(vardata);
     531          50 :         return result;
     532             :     }
     533             : 
     534             :     /*
     535             :      * If the constant is NULL, assume operator is strict and return zero, ie,
     536             :      * operator will never return TRUE.  (It's zero even for a negator op.)
     537             :      */
     538        9732 :     if (((Const *) other)->constisnull)
     539             :     {
     540           0 :         ReleaseVariableStats(vardata);
     541           0 :         return 0.0;
     542             :     }
     543        9732 :     constval = ((Const *) other)->constvalue;
     544        9732 :     consttype = ((Const *) other)->consttype;
     545             : 
     546             :     /*
     547             :      * The right-hand const is type text or bytea for all supported operators.
     548             :      * We do not expect to see binary-compatible types here, since
     549             :      * const-folding should have relabeled the const to exactly match the
     550             :      * operator's declared type.
     551             :      */
     552        9732 :     if (consttype != TEXTOID && consttype != BYTEAOID)
     553             :     {
     554          24 :         ReleaseVariableStats(vardata);
     555          24 :         return result;
     556             :     }
     557             : 
     558             :     /*
     559             :      * Similarly, the exposed type of the left-hand side should be one of
     560             :      * those we know.  (Do not look at vardata.atttype, which might be
     561             :      * something binary-compatible but different.)  We can use it to identify
     562             :      * the comparison operators and the required type of the comparison
     563             :      * constant, much as in match_pattern_prefix().
     564             :      */
     565        9708 :     vartype = vardata.vartype;
     566             : 
     567        9708 :     switch (vartype)
     568             :     {
     569        1434 :         case TEXTOID:
     570        1434 :             eqopr = TextEqualOperator;
     571        1434 :             ltopr = TextLessOperator;
     572        1434 :             geopr = TextGreaterEqualOperator;
     573        1434 :             rdatatype = TEXTOID;
     574        1434 :             break;
     575        8180 :         case NAMEOID:
     576             : 
     577             :             /*
     578             :              * Note that here, we need the RHS type to be text, so that the
     579             :              * comparison value isn't improperly truncated to NAMEDATALEN.
     580             :              */
     581        8180 :             eqopr = NameEqualTextOperator;
     582        8180 :             ltopr = NameLessTextOperator;
     583        8180 :             geopr = NameGreaterEqualTextOperator;
     584        8180 :             rdatatype = TEXTOID;
     585        8180 :             break;
     586          84 :         case BPCHAROID:
     587          84 :             eqopr = BpcharEqualOperator;
     588          84 :             ltopr = BpcharLessOperator;
     589          84 :             geopr = BpcharGreaterEqualOperator;
     590          84 :             rdatatype = BPCHAROID;
     591          84 :             break;
     592           6 :         case BYTEAOID:
     593           6 :             eqopr = ByteaEqualOperator;
     594           6 :             ltopr = ByteaLessOperator;
     595           6 :             geopr = ByteaGreaterEqualOperator;
     596           6 :             rdatatype = BYTEAOID;
     597           6 :             break;
     598           4 :         default:
     599             :             /* Can't get here unless we're attached to the wrong operator */
     600           4 :             ReleaseVariableStats(vardata);
     601           4 :             return result;
     602             :     }
     603             : 
     604             :     /*
     605             :      * Grab the nullfrac for use below.
     606             :      */
     607        9704 :     if (HeapTupleIsValid(vardata.statsTuple))
     608             :     {
     609             :         Form_pg_statistic stats;
     610             : 
     611        7822 :         stats = (Form_pg_statistic) GETSTRUCT(vardata.statsTuple);
     612        7822 :         nullfrac = stats->stanullfrac;
     613             :     }
     614             : 
     615             :     /*
     616             :      * Pull out any fixed prefix implied by the pattern, and estimate the
     617             :      * fractional selectivity of the remainder of the pattern.  Unlike many
     618             :      * other selectivity estimators, we use the pattern operator's actual
     619             :      * collation for this step.  This is not because we expect the collation
     620             :      * to make a big difference in the selectivity estimate (it seldom would),
     621             :      * but because we want to be sure we cache compiled regexps under the
     622             :      * right cache key, so that they can be re-used at runtime.
     623             :      */
     624        9704 :     patt = (Const *) other;
     625        9704 :     pstatus = pattern_fixed_prefix(patt, ptype, collation,
     626             :                                    &prefix, &rest_selec);
     627             : 
     628             :     /*
     629             :      * If necessary, coerce the prefix constant to the right type.  The only
     630             :      * case where we need to do anything is when converting text to bpchar.
     631             :      * Those two types are binary-compatible, so relabeling the Const node is
     632             :      * sufficient.
     633             :      */
     634        9680 :     if (prefix && prefix->consttype != rdatatype)
     635             :     {
     636             :         Assert(prefix->consttype == TEXTOID &&
     637             :                rdatatype == BPCHAROID);
     638          36 :         prefix->consttype = rdatatype;
     639             :     }
     640             : 
     641        9680 :     if (pstatus == Pattern_Prefix_Exact)
     642             :     {
     643             :         /*
     644             :          * Pattern specifies an exact match, so estimate as for '='
     645             :          */
     646        5754 :         result = var_eq_const(&vardata, eqopr, collation, prefix->constvalue,
     647             :                               false, true, false);
     648             :     }
     649             :     else
     650             :     {
     651             :         /*
     652             :          * Not exact-match pattern.  If we have a sufficiently large
     653             :          * histogram, estimate selectivity for the histogram part of the
     654             :          * population by counting matches in the histogram.  If not, estimate
     655             :          * selectivity of the fixed prefix and remainder of pattern
     656             :          * separately, then combine the two to get an estimate of the
     657             :          * selectivity for the part of the column population represented by
     658             :          * the histogram.  (For small histograms, we combine these
     659             :          * approaches.)
     660             :          *
     661             :          * We then add up data for any most-common-values values; these are
     662             :          * not in the histogram population, and we can get exact answers for
     663             :          * them by applying the pattern operator, so there's no reason to
     664             :          * approximate.  (If the MCVs cover a significant part of the total
     665             :          * population, this gives us a big leg up in accuracy.)
     666             :          */
     667             :         Selectivity selec;
     668             :         int         hist_size;
     669             :         FmgrInfo    opproc;
     670             :         double      mcv_selec,
     671             :                     sumcommon;
     672             : 
     673             :         /* Try to use the histogram entries to get selectivity */
     674        3926 :         if (!OidIsValid(opfuncid))
     675        3902 :             opfuncid = get_opcode(oprid);
     676        3926 :         fmgr_info(opfuncid, &opproc);
     677             : 
     678        3926 :         selec = histogram_selectivity(&vardata, &opproc, collation,
     679             :                                       constval, true,
     680             :                                       10, 1, &hist_size);
     681             : 
     682             :         /* If not at least 100 entries, use the heuristic method */
     683        3926 :         if (hist_size < 100)
     684             :         {
     685             :             Selectivity heursel;
     686             :             Selectivity prefixsel;
     687             : 
     688        2594 :             if (pstatus == Pattern_Prefix_Partial)
     689        1858 :                 prefixsel = prefix_selectivity(root, &vardata,
     690             :                                                eqopr, ltopr, geopr,
     691             :                                                collation,
     692             :                                                prefix);
     693             :             else
     694         736 :                 prefixsel = 1.0;
     695        2594 :             heursel = prefixsel * rest_selec;
     696             : 
     697        2594 :             if (selec < 0)       /* fewer than 10 histogram entries? */
     698        2338 :                 selec = heursel;
     699             :             else
     700             :             {
     701             :                 /*
     702             :                  * For histogram sizes from 10 to 100, we combine the
     703             :                  * histogram and heuristic selectivities, putting increasingly
     704             :                  * more trust in the histogram for larger sizes.
     705             :                  */
     706         256 :                 double      hist_weight = hist_size / 100.0;
     707             : 
     708         256 :                 selec = selec * hist_weight + heursel * (1.0 - hist_weight);
     709             :             }
     710             :         }
     711             : 
     712             :         /* In any case, don't believe extremely small or large estimates. */
     713        3926 :         if (selec < 0.0001)
     714        1322 :             selec = 0.0001;
     715        2604 :         else if (selec > 0.9999)
     716         130 :             selec = 0.9999;
     717             : 
     718             :         /*
     719             :          * If we have most-common-values info, add up the fractions of the MCV
     720             :          * entries that satisfy MCV OP PATTERN.  These fractions contribute
     721             :          * directly to the result selectivity.  Also add up the total fraction
     722             :          * represented by MCV entries.
     723             :          */
     724        3926 :         mcv_selec = mcv_selectivity(&vardata, &opproc, collation,
     725             :                                     constval, true,
     726             :                                     &sumcommon);
     727             : 
     728             :         /*
     729             :          * Now merge the results from the MCV and histogram calculations,
     730             :          * realizing that the histogram covers only the non-null values that
     731             :          * are not listed in MCV.
     732             :          */
     733        3926 :         selec *= 1.0 - nullfrac - sumcommon;
     734        3926 :         selec += mcv_selec;
     735        3926 :         result = selec;
     736             :     }
     737             : 
     738             :     /* now adjust if we wanted not-match rather than match */
     739        9680 :     if (negate)
     740        1344 :         result = 1.0 - result - nullfrac;
     741             : 
     742             :     /* result should be in range, but make sure... */
     743        9680 :     CLAMP_PROBABILITY(result);
     744             : 
     745        9680 :     if (prefix)
     746             :     {
     747        9090 :         pfree(DatumGetPointer(prefix->constvalue));
     748        9090 :         pfree(prefix);
     749             :     }
     750             : 
     751        9680 :     ReleaseVariableStats(vardata);
     752             : 
     753        9680 :     return result;
     754             : }
     755             : 
     756             : /*
     757             :  * Fix impedance mismatch between SQL-callable functions and patternsel_common
     758             :  */
     759             : static double
     760       10014 : patternsel(PG_FUNCTION_ARGS, Pattern_Type ptype, bool negate)
     761             : {
     762       10014 :     PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);
     763       10014 :     Oid         operator = PG_GETARG_OID(1);
     764       10014 :     List       *args = (List *) PG_GETARG_POINTER(2);
     765       10014 :     int         varRelid = PG_GETARG_INT32(3);
     766       10014 :     Oid         collation = PG_GET_COLLATION();
     767             : 
     768             :     /*
     769             :      * If this is for a NOT LIKE or similar operator, get the corresponding
     770             :      * positive-match operator and work with that.
     771             :      */
     772       10014 :     if (negate)
     773             :     {
     774        1576 :         operator = get_negator(operator);
     775        1576 :         if (!OidIsValid(operator))
     776           0 :             elog(ERROR, "patternsel called for operator without a negator");
     777             :     }
     778             : 
     779       10014 :     return patternsel_common(root,
     780             :                              operator,
     781             :                              InvalidOid,
     782             :                              args,
     783             :                              varRelid,
     784             :                              collation,
     785             :                              ptype,
     786             :                              negate);
     787             : }
     788             : 
     789             : /*
     790             :  *      regexeqsel      - Selectivity of regular-expression pattern match.
     791             :  */
     792             : Datum
     793        6692 : regexeqsel(PG_FUNCTION_ARGS)
     794             : {
     795        6692 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Regex, false));
     796             : }
     797             : 
     798             : /*
     799             :  *      icregexeqsel    - Selectivity of case-insensitive regex match.
     800             :  */
     801             : Datum
     802          64 : icregexeqsel(PG_FUNCTION_ARGS)
     803             : {
     804          64 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Regex_IC, false));
     805             : }
     806             : 
     807             : /*
     808             :  *      likesel         - Selectivity of LIKE pattern match.
     809             :  */
     810             : Datum
     811        1500 : likesel(PG_FUNCTION_ARGS)
     812             : {
     813        1500 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Like, false));
     814             : }
     815             : 
     816             : /*
     817             :  *      prefixsel           - selectivity of prefix operator
     818             :  */
     819             : Datum
     820          54 : prefixsel(PG_FUNCTION_ARGS)
     821             : {
     822          54 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Prefix, false));
     823             : }
     824             : 
     825             : /*
     826             :  *
     827             :  *      iclikesel           - Selectivity of ILIKE pattern match.
     828             :  */
     829             : Datum
     830         128 : iclikesel(PG_FUNCTION_ARGS)
     831             : {
     832         128 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Like_IC, false));
     833             : }
     834             : 
     835             : /*
     836             :  *      regexnesel      - Selectivity of regular-expression pattern non-match.
     837             :  */
     838             : Datum
     839        1416 : regexnesel(PG_FUNCTION_ARGS)
     840             : {
     841        1416 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Regex, true));
     842             : }
     843             : 
     844             : /*
     845             :  *      icregexnesel    - Selectivity of case-insensitive regex non-match.
     846             :  */
     847             : Datum
     848          16 : icregexnesel(PG_FUNCTION_ARGS)
     849             : {
     850          16 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Regex_IC, true));
     851             : }
     852             : 
     853             : /*
     854             :  *      nlikesel        - Selectivity of LIKE pattern non-match.
     855             :  */
     856             : Datum
     857         136 : nlikesel(PG_FUNCTION_ARGS)
     858             : {
     859         136 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Like, true));
     860             : }
     861             : 
     862             : /*
     863             :  *      icnlikesel      - Selectivity of ILIKE pattern non-match.
     864             :  */
     865             : Datum
     866           8 : icnlikesel(PG_FUNCTION_ARGS)
     867             : {
     868           8 :     PG_RETURN_FLOAT8(patternsel(fcinfo, Pattern_Type_Like_IC, true));
     869             : }
     870             : 
     871             : /*
     872             :  * patternjoinsel       - Generic code for pattern-match join selectivity.
     873             :  */
     874             : static double
     875         248 : patternjoinsel(PG_FUNCTION_ARGS, Pattern_Type ptype, bool negate)
     876             : {
     877             :     /* For the moment we just punt. */
     878         248 :     return negate ? (1.0 - DEFAULT_MATCH_SEL) : DEFAULT_MATCH_SEL;
     879             : }
     880             : 
     881             : /*
     882             :  *      regexeqjoinsel  - Join selectivity of regular-expression pattern match.
     883             :  */
     884             : Datum
     885         236 : regexeqjoinsel(PG_FUNCTION_ARGS)
     886             : {
     887         236 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Regex, false));
     888             : }
     889             : 
     890             : /*
     891             :  *      icregexeqjoinsel    - Join selectivity of case-insensitive regex match.
     892             :  */
     893             : Datum
     894           0 : icregexeqjoinsel(PG_FUNCTION_ARGS)
     895             : {
     896           0 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Regex_IC, false));
     897             : }
     898             : 
     899             : /*
     900             :  *      likejoinsel         - Join selectivity of LIKE pattern match.
     901             :  */
     902             : Datum
     903          12 : likejoinsel(PG_FUNCTION_ARGS)
     904             : {
     905          12 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Like, false));
     906             : }
     907             : 
     908             : /*
     909             :  *      prefixjoinsel           - Join selectivity of prefix operator
     910             :  */
     911             : Datum
     912           0 : prefixjoinsel(PG_FUNCTION_ARGS)
     913             : {
     914           0 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Prefix, false));
     915             : }
     916             : 
     917             : /*
     918             :  *      iclikejoinsel           - Join selectivity of ILIKE pattern match.
     919             :  */
     920             : Datum
     921           0 : iclikejoinsel(PG_FUNCTION_ARGS)
     922             : {
     923           0 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Like_IC, false));
     924             : }
     925             : 
     926             : /*
     927             :  *      regexnejoinsel  - Join selectivity of regex non-match.
     928             :  */
     929             : Datum
     930           0 : regexnejoinsel(PG_FUNCTION_ARGS)
     931             : {
     932           0 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Regex, true));
     933             : }
     934             : 
     935             : /*
     936             :  *      icregexnejoinsel    - Join selectivity of case-insensitive regex non-match.
     937             :  */
     938             : Datum
     939           0 : icregexnejoinsel(PG_FUNCTION_ARGS)
     940             : {
     941           0 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Regex_IC, true));
     942             : }
     943             : 
     944             : /*
     945             :  *      nlikejoinsel        - Join selectivity of LIKE pattern non-match.
     946             :  */
     947             : Datum
     948           0 : nlikejoinsel(PG_FUNCTION_ARGS)
     949             : {
     950           0 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Like, true));
     951             : }
     952             : 
     953             : /*
     954             :  *      icnlikejoinsel      - Join selectivity of ILIKE pattern non-match.
     955             :  */
     956             : Datum
     957           0 : icnlikejoinsel(PG_FUNCTION_ARGS)
     958             : {
     959           0 :     PG_RETURN_FLOAT8(patternjoinsel(fcinfo, Pattern_Type_Like_IC, true));
     960             : }
     961             : 
     962             : 
     963             : /*-------------------------------------------------------------------------
     964             :  *
     965             :  * Pattern analysis functions
     966             :  *
     967             :  * These routines support analysis of LIKE and regular-expression patterns
     968             :  * by the planner/optimizer.  It's important that they agree with the
     969             :  * regular-expression code in backend/regex/ and the LIKE code in
     970             :  * backend/utils/adt/like.c.  Also, the computation of the fixed prefix
     971             :  * must be conservative: if we report a string longer than the true fixed
     972             :  * prefix, the query may produce actually wrong answers, rather than just
     973             :  * getting a bad selectivity estimate!
     974             :  *
     975             :  *-------------------------------------------------------------------------
     976             :  */
     977             : 
     978             : /*
     979             :  * Extract the fixed prefix, if any, for a pattern.
     980             :  *
     981             :  * *prefix is set to a palloc'd prefix string (in the form of a Const node),
     982             :  *  or to NULL if no fixed prefix exists for the pattern.
     983             :  * If rest_selec is not NULL, *rest_selec is set to an estimate of the
     984             :  *  selectivity of the remainder of the pattern (without any fixed prefix).
     985             :  * The prefix Const has the same type (TEXT or BYTEA) as the input pattern.
     986             :  *
     987             :  * The return value distinguishes no fixed prefix, a partial prefix,
     988             :  * or an exact-match-only pattern.
     989             :  */
     990             : 
     991             : static Pattern_Prefix_Status
     992        2886 : like_fixed_prefix(Const *patt_const, bool case_insensitive, Oid collation,
     993             :                   Const **prefix_const, Selectivity *rest_selec)
     994             : {
     995             :     char       *match;
     996             :     char       *patt;
     997             :     int         pattlen;
     998        2886 :     Oid         typeid = patt_const->consttype;
     999             :     int         pos,
    1000             :                 match_pos;
    1001        2886 :     bool        is_multibyte = (pg_database_encoding_max_length() > 1);
    1002        2886 :     pg_locale_t locale = 0;
    1003             : 
    1004             :     /* the right-hand const is type text or bytea */
    1005             :     Assert(typeid == BYTEAOID || typeid == TEXTOID);
    1006             : 
    1007        2886 :     if (case_insensitive)
    1008             :     {
    1009         238 :         if (typeid == BYTEAOID)
    1010           0 :             ereport(ERROR,
    1011             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1012             :                      errmsg("case insensitive matching not supported on type bytea")));
    1013             : 
    1014         238 :         if (!OidIsValid(collation))
    1015             :         {
    1016             :             /*
    1017             :              * This typically means that the parser could not resolve a
    1018             :              * conflict of implicit collations, so report it that way.
    1019             :              */
    1020           0 :             ereport(ERROR,
    1021             :                     (errcode(ERRCODE_INDETERMINATE_COLLATION),
    1022             :                      errmsg("could not determine which collation to use for ILIKE"),
    1023             :                      errhint("Use the COLLATE clause to set the collation explicitly.")));
    1024             :         }
    1025             : 
    1026         238 :         locale = pg_newlocale_from_collation(collation);
    1027             :     }
    1028             : 
    1029        2886 :     if (typeid != BYTEAOID)
    1030             :     {
    1031        2874 :         patt = TextDatumGetCString(patt_const->constvalue);
    1032        2874 :         pattlen = strlen(patt);
    1033             :     }
    1034             :     else
    1035             :     {
    1036          12 :         bytea      *bstr = DatumGetByteaPP(patt_const->constvalue);
    1037             : 
    1038          12 :         pattlen = VARSIZE_ANY_EXHDR(bstr);
    1039          12 :         patt = (char *) palloc(pattlen);
    1040          12 :         memcpy(patt, VARDATA_ANY(bstr), pattlen);
    1041             :         Assert((Pointer) bstr == DatumGetPointer(patt_const->constvalue));
    1042             :     }
    1043             : 
    1044        2886 :     match = palloc(pattlen + 1);
    1045        2886 :     match_pos = 0;
    1046       15350 :     for (pos = 0; pos < pattlen; pos++)
    1047             :     {
    1048             :         /* % and _ are wildcard characters in LIKE */
    1049       15262 :         if (patt[pos] == '%' ||
    1050       13688 :             patt[pos] == '_')
    1051             :             break;
    1052             : 
    1053             :         /* Backslash escapes the next character */
    1054       12638 :         if (patt[pos] == '\\')
    1055             :         {
    1056         262 :             pos++;
    1057         262 :             if (pos >= pattlen)
    1058           0 :                 break;
    1059             :         }
    1060             : 
    1061             :         /* Stop if case-varying character (it's sort of a wildcard) */
    1062       12908 :         if (case_insensitive &&
    1063         270 :             pattern_char_isalpha(patt[pos], is_multibyte, locale))
    1064         174 :             break;
    1065             : 
    1066       12464 :         match[match_pos++] = patt[pos];
    1067             :     }
    1068             : 
    1069        2886 :     match[match_pos] = '\0';
    1070             : 
    1071        2886 :     if (typeid != BYTEAOID)
    1072        2874 :         *prefix_const = string_to_const(match, typeid);
    1073             :     else
    1074          12 :         *prefix_const = string_to_bytea_const(match, match_pos);
    1075             : 
    1076        2886 :     if (rest_selec != NULL)
    1077        1756 :         *rest_selec = like_selectivity(&patt[pos], pattlen - pos,
    1078             :                                        case_insensitive);
    1079             : 
    1080        2886 :     pfree(patt);
    1081        2886 :     pfree(match);
    1082             : 
    1083             :     /* in LIKE, an empty pattern is an exact match! */
    1084        2886 :     if (pos == pattlen)
    1085          88 :         return Pattern_Prefix_Exact;    /* reached end of pattern, so exact */
    1086             : 
    1087        2798 :     if (match_pos > 0)
    1088        2260 :         return Pattern_Prefix_Partial;
    1089             : 
    1090         538 :     return Pattern_Prefix_None;
    1091             : }
    1092             : 
    1093             : static Pattern_Prefix_Status
    1094       13860 : regex_fixed_prefix(Const *patt_const, bool case_insensitive, Oid collation,
    1095             :                    Const **prefix_const, Selectivity *rest_selec)
    1096             : {
    1097       13860 :     Oid         typeid = patt_const->consttype;
    1098             :     char       *prefix;
    1099             :     bool        exact;
    1100             : 
    1101             :     /*
    1102             :      * Should be unnecessary, there are no bytea regex operators defined. As
    1103             :      * such, it should be noted that the rest of this function has *not* been
    1104             :      * made safe for binary (possibly NULL containing) strings.
    1105             :      */
    1106       13860 :     if (typeid == BYTEAOID)
    1107           0 :         ereport(ERROR,
    1108             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1109             :                  errmsg("regular-expression matching not supported on type bytea")));
    1110             : 
    1111             :     /* Use the regexp machinery to extract the prefix, if any */
    1112       13860 :     prefix = regexp_fixed_prefix(DatumGetTextPP(patt_const->constvalue),
    1113             :                                  case_insensitive, collation,
    1114             :                                  &exact);
    1115             : 
    1116       13836 :     if (prefix == NULL)
    1117             :     {
    1118         720 :         *prefix_const = NULL;
    1119             : 
    1120         720 :         if (rest_selec != NULL)
    1121             :         {
    1122         590 :             char       *patt = TextDatumGetCString(patt_const->constvalue);
    1123             : 
    1124         590 :             *rest_selec = regex_selectivity(patt, strlen(patt),
    1125             :                                             case_insensitive,
    1126             :                                             0);
    1127         590 :             pfree(patt);
    1128             :         }
    1129             : 
    1130         720 :         return Pattern_Prefix_None;
    1131             :     }
    1132             : 
    1133       13116 :     *prefix_const = string_to_const(prefix, typeid);
    1134             : 
    1135       13116 :     if (rest_selec != NULL)
    1136             :     {
    1137        7256 :         if (exact)
    1138             :         {
    1139             :             /* Exact match, so there's no additional selectivity */
    1140        5702 :             *rest_selec = 1.0;
    1141             :         }
    1142             :         else
    1143             :         {
    1144        1554 :             char       *patt = TextDatumGetCString(patt_const->constvalue);
    1145             : 
    1146        3108 :             *rest_selec = regex_selectivity(patt, strlen(patt),
    1147             :                                             case_insensitive,
    1148        1554 :                                             strlen(prefix));
    1149        1554 :             pfree(patt);
    1150             :         }
    1151             :     }
    1152             : 
    1153       13116 :     pfree(prefix);
    1154             : 
    1155       13116 :     if (exact)
    1156       11254 :         return Pattern_Prefix_Exact;    /* pattern specifies exact match */
    1157             :     else
    1158        1862 :         return Pattern_Prefix_Partial;
    1159             : }
    1160             : 
    1161             : static Pattern_Prefix_Status
    1162       16848 : pattern_fixed_prefix(Const *patt, Pattern_Type ptype, Oid collation,
    1163             :                      Const **prefix, Selectivity *rest_selec)
    1164             : {
    1165             :     Pattern_Prefix_Status result;
    1166             : 
    1167       16848 :     switch (ptype)
    1168             :     {
    1169        2648 :         case Pattern_Type_Like:
    1170        2648 :             result = like_fixed_prefix(patt, false, collation,
    1171             :                                        prefix, rest_selec);
    1172        2648 :             break;
    1173         238 :         case Pattern_Type_Like_IC:
    1174         238 :             result = like_fixed_prefix(patt, true, collation,
    1175             :                                        prefix, rest_selec);
    1176         238 :             break;
    1177       13798 :         case Pattern_Type_Regex:
    1178       13798 :             result = regex_fixed_prefix(patt, false, collation,
    1179             :                                         prefix, rest_selec);
    1180       13774 :             break;
    1181          62 :         case Pattern_Type_Regex_IC:
    1182          62 :             result = regex_fixed_prefix(patt, true, collation,
    1183             :                                         prefix, rest_selec);
    1184          62 :             break;
    1185         102 :         case Pattern_Type_Prefix:
    1186             :             /* Prefix type work is trivial.  */
    1187         102 :             result = Pattern_Prefix_Partial;
    1188         102 :             *prefix = makeConst(patt->consttype,
    1189             :                                 patt->consttypmod,
    1190             :                                 patt->constcollid,
    1191             :                                 patt->constlen,
    1192             :                                 datumCopy(patt->constvalue,
    1193         102 :                                           patt->constbyval,
    1194             :                                           patt->constlen),
    1195         102 :                                 patt->constisnull,
    1196         102 :                                 patt->constbyval);
    1197         102 :             if (rest_selec != NULL)
    1198          78 :                 *rest_selec = 1.0;  /* all */
    1199         102 :             break;
    1200           0 :         default:
    1201           0 :             elog(ERROR, "unrecognized ptype: %d", (int) ptype);
    1202             :             result = Pattern_Prefix_None;   /* keep compiler quiet */
    1203             :             break;
    1204             :     }
    1205       16824 :     return result;
    1206             : }
    1207             : 
    1208             : /*
    1209             :  * Estimate the selectivity of a fixed prefix for a pattern match.
    1210             :  *
    1211             :  * A fixed prefix "foo" is estimated as the selectivity of the expression
    1212             :  * "variable >= 'foo' AND variable < 'fop'".
    1213             :  *
    1214             :  * The selectivity estimate is with respect to the portion of the column
    1215             :  * population represented by the histogram --- the caller must fold this
    1216             :  * together with info about MCVs and NULLs.
    1217             :  *
    1218             :  * We use the given comparison operators and collation to do the estimation.
    1219             :  * The given variable and Const must be of the associated datatype(s).
    1220             :  *
    1221             :  * XXX Note: we make use of the upper bound to estimate operator selectivity
    1222             :  * even if the locale is such that we cannot rely on the upper-bound string.
    1223             :  * The selectivity only needs to be approximately right anyway, so it seems
    1224             :  * more useful to use the upper-bound code than not.
    1225             :  */
    1226             : static Selectivity
    1227        1858 : prefix_selectivity(PlannerInfo *root, VariableStatData *vardata,
    1228             :                    Oid eqopr, Oid ltopr, Oid geopr,
    1229             :                    Oid collation,
    1230             :                    Const *prefixcon)
    1231             : {
    1232             :     Selectivity prefixsel;
    1233             :     FmgrInfo    opproc;
    1234             :     Const      *greaterstrcon;
    1235             :     Selectivity eq_sel;
    1236             : 
    1237             :     /* Estimate the selectivity of "x >= prefix" */
    1238        1858 :     fmgr_info(get_opcode(geopr), &opproc);
    1239             : 
    1240        1858 :     prefixsel = ineq_histogram_selectivity(root, vardata,
    1241             :                                            geopr, &opproc, true, true,
    1242             :                                            collation,
    1243             :                                            prefixcon->constvalue,
    1244             :                                            prefixcon->consttype);
    1245             : 
    1246        1858 :     if (prefixsel < 0.0)
    1247             :     {
    1248             :         /* No histogram is present ... return a suitable default estimate */
    1249         618 :         return DEFAULT_MATCH_SEL;
    1250             :     }
    1251             : 
    1252             :     /*
    1253             :      * If we can create a string larger than the prefix, say "x < greaterstr".
    1254             :      */
    1255        1240 :     fmgr_info(get_opcode(ltopr), &opproc);
    1256        1240 :     greaterstrcon = make_greater_string(prefixcon, &opproc, collation);
    1257        1240 :     if (greaterstrcon)
    1258             :     {
    1259             :         Selectivity topsel;
    1260             : 
    1261        1240 :         topsel = ineq_histogram_selectivity(root, vardata,
    1262             :                                             ltopr, &opproc, false, false,
    1263             :                                             collation,
    1264             :                                             greaterstrcon->constvalue,
    1265             :                                             greaterstrcon->consttype);
    1266             : 
    1267             :         /* ineq_histogram_selectivity worked before, it shouldn't fail now */
    1268             :         Assert(topsel >= 0.0);
    1269             : 
    1270             :         /*
    1271             :          * Merge the two selectivities in the same way as for a range query
    1272             :          * (see clauselist_selectivity()).  Note that we don't need to worry
    1273             :          * about double-exclusion of nulls, since ineq_histogram_selectivity
    1274             :          * doesn't count those anyway.
    1275             :          */
    1276        1240 :         prefixsel = topsel + prefixsel - 1.0;
    1277             :     }
    1278             : 
    1279             :     /*
    1280             :      * If the prefix is long then the two bounding values might be too close
    1281             :      * together for the histogram to distinguish them usefully, resulting in a
    1282             :      * zero estimate (plus or minus roundoff error). To avoid returning a
    1283             :      * ridiculously small estimate, compute the estimated selectivity for
    1284             :      * "variable = 'foo'", and clamp to that. (Obviously, the resultant
    1285             :      * estimate should be at least that.)
    1286             :      *
    1287             :      * We apply this even if we couldn't make a greater string.  That case
    1288             :      * suggests that the prefix is near the maximum possible, and thus
    1289             :      * probably off the end of the histogram, and thus we probably got a very
    1290             :      * small estimate from the >= condition; so we still need to clamp.
    1291             :      */
    1292        1240 :     eq_sel = var_eq_const(vardata, eqopr, collation, prefixcon->constvalue,
    1293             :                           false, true, false);
    1294             : 
    1295        1240 :     prefixsel = Max(prefixsel, eq_sel);
    1296             : 
    1297        1240 :     return prefixsel;
    1298             : }
    1299             : 
    1300             : 
    1301             : /*
    1302             :  * Estimate the selectivity of a pattern of the specified type.
    1303             :  * Note that any fixed prefix of the pattern will have been removed already,
    1304             :  * so actually we may be looking at just a fragment of the pattern.
    1305             :  *
    1306             :  * For now, we use a very simplistic approach: fixed characters reduce the
    1307             :  * selectivity a good deal, character ranges reduce it a little,
    1308             :  * wildcards (such as % for LIKE or .* for regex) increase it.
    1309             :  */
    1310             : 
    1311             : #define FIXED_CHAR_SEL  0.20    /* about 1/5 */
    1312             : #define CHAR_RANGE_SEL  0.25
    1313             : #define ANY_CHAR_SEL    0.9     /* not 1, since it won't match end-of-string */
    1314             : #define FULL_WILDCARD_SEL 5.0
    1315             : #define PARTIAL_WILDCARD_SEL 2.0
    1316             : 
    1317             : static Selectivity
    1318        1756 : like_selectivity(const char *patt, int pattlen, bool case_insensitive)
    1319             : {
    1320        1756 :     Selectivity sel = 1.0;
    1321             :     int         pos;
    1322             : 
    1323             :     /* Skip any leading wildcard; it's already factored into initial sel */
    1324        3398 :     for (pos = 0; pos < pattlen; pos++)
    1325             :     {
    1326        2496 :         if (patt[pos] != '%' && patt[pos] != '_')
    1327         854 :             break;
    1328             :     }
    1329             : 
    1330        6830 :     for (; pos < pattlen; pos++)
    1331             :     {
    1332             :         /* % and _ are wildcard characters in LIKE */
    1333        5074 :         if (patt[pos] == '%')
    1334         750 :             sel *= FULL_WILDCARD_SEL;
    1335        4324 :         else if (patt[pos] == '_')
    1336         172 :             sel *= ANY_CHAR_SEL;
    1337        4152 :         else if (patt[pos] == '\\')
    1338             :         {
    1339             :             /* Backslash quotes the next character */
    1340          40 :             pos++;
    1341          40 :             if (pos >= pattlen)
    1342           0 :                 break;
    1343          40 :             sel *= FIXED_CHAR_SEL;
    1344             :         }
    1345             :         else
    1346        4112 :             sel *= FIXED_CHAR_SEL;
    1347             :     }
    1348             :     /* Could get sel > 1 if multiple wildcards */
    1349        1756 :     if (sel > 1.0)
    1350           0 :         sel = 1.0;
    1351        1756 :     return sel;
    1352             : }
    1353             : 
    1354             : static Selectivity
    1355        2462 : regex_selectivity_sub(const char *patt, int pattlen, bool case_insensitive)
    1356             : {
    1357        2462 :     Selectivity sel = 1.0;
    1358        2462 :     int         paren_depth = 0;
    1359        2462 :     int         paren_pos = 0;  /* dummy init to keep compiler quiet */
    1360             :     int         pos;
    1361             : 
    1362             :     /* since this function recurses, it could be driven to stack overflow */
    1363        2462 :     check_stack_depth();
    1364             : 
    1365       25526 :     for (pos = 0; pos < pattlen; pos++)
    1366             :     {
    1367       23082 :         if (patt[pos] == '(')
    1368             :         {
    1369         306 :             if (paren_depth == 0)
    1370         300 :                 paren_pos = pos;    /* remember start of parenthesized item */
    1371         306 :             paren_depth++;
    1372             :         }
    1373       22776 :         else if (patt[pos] == ')' && paren_depth > 0)
    1374             :         {
    1375         306 :             paren_depth--;
    1376         306 :             if (paren_depth == 0)
    1377         300 :                 sel *= regex_selectivity_sub(patt + (paren_pos + 1),
    1378         300 :                                              pos - (paren_pos + 1),
    1379             :                                              case_insensitive);
    1380             :         }
    1381       22470 :         else if (patt[pos] == '|' && paren_depth == 0)
    1382             :         {
    1383             :             /*
    1384             :              * If unquoted | is present at paren level 0 in pattern, we have
    1385             :              * multiple alternatives; sum their probabilities.
    1386             :              */
    1387          36 :             sel += regex_selectivity_sub(patt + (pos + 1),
    1388          18 :                                          pattlen - (pos + 1),
    1389             :                                          case_insensitive);
    1390          18 :             break;              /* rest of pattern is now processed */
    1391             :         }
    1392       22452 :         else if (patt[pos] == '[')
    1393             :         {
    1394          78 :             bool        negclass = false;
    1395             : 
    1396          78 :             if (patt[++pos] == '^')
    1397             :             {
    1398           0 :                 negclass = true;
    1399           0 :                 pos++;
    1400             :             }
    1401          78 :             if (patt[pos] == ']')   /* ']' at start of class is not special */
    1402           0 :                 pos++;
    1403         380 :             while (pos < pattlen && patt[pos] != ']')
    1404         302 :                 pos++;
    1405          78 :             if (paren_depth == 0)
    1406          78 :                 sel *= (negclass ? (1.0 - CHAR_RANGE_SEL) : CHAR_RANGE_SEL);
    1407             :         }
    1408       22374 :         else if (patt[pos] == '.')
    1409             :         {
    1410         734 :             if (paren_depth == 0)
    1411         430 :                 sel *= ANY_CHAR_SEL;
    1412             :         }
    1413       21640 :         else if (patt[pos] == '*' ||
    1414       20984 :                  patt[pos] == '?' ||
    1415       20932 :                  patt[pos] == '+')
    1416             :         {
    1417             :             /* Ought to be smarter about quantifiers... */
    1418         722 :             if (paren_depth == 0)
    1419         408 :                 sel *= PARTIAL_WILDCARD_SEL;
    1420             :         }
    1421       20918 :         else if (patt[pos] == '{')
    1422             :         {
    1423         264 :             while (pos < pattlen && patt[pos] != '}')
    1424         188 :                 pos++;
    1425          76 :             if (paren_depth == 0)
    1426          64 :                 sel *= PARTIAL_WILDCARD_SEL;
    1427             :         }
    1428       20842 :         else if (patt[pos] == '\\')
    1429             :         {
    1430             :             /* backslash quotes the next character */
    1431         200 :             pos++;
    1432         200 :             if (pos >= pattlen)
    1433           0 :                 break;
    1434         200 :             if (paren_depth == 0)
    1435         104 :                 sel *= FIXED_CHAR_SEL;
    1436             :         }
    1437             :         else
    1438             :         {
    1439       20642 :             if (paren_depth == 0)
    1440       18472 :                 sel *= FIXED_CHAR_SEL;
    1441             :         }
    1442             :     }
    1443             :     /* Could get sel > 1 if multiple wildcards */
    1444        2462 :     if (sel > 1.0)
    1445          26 :         sel = 1.0;
    1446        2462 :     return sel;
    1447             : }
    1448             : 
    1449             : static Selectivity
    1450        2144 : regex_selectivity(const char *patt, int pattlen, bool case_insensitive,
    1451             :                   int fixed_prefix_len)
    1452             : {
    1453             :     Selectivity sel;
    1454             : 
    1455             :     /* If patt doesn't end with $, consider it to have a trailing wildcard */
    1456        2144 :     if (pattlen > 0 && patt[pattlen - 1] == '$' &&
    1457         300 :         (pattlen == 1 || patt[pattlen - 2] != '\\'))
    1458             :     {
    1459             :         /* has trailing $ */
    1460         300 :         sel = regex_selectivity_sub(patt, pattlen - 1, case_insensitive);
    1461             :     }
    1462             :     else
    1463             :     {
    1464             :         /* no trailing $ */
    1465        1844 :         sel = regex_selectivity_sub(patt, pattlen, case_insensitive);
    1466        1844 :         sel *= FULL_WILDCARD_SEL;
    1467             :     }
    1468             : 
    1469             :     /*
    1470             :      * If there's a fixed prefix, discount its selectivity.  We have to be
    1471             :      * careful here since a very long prefix could result in pow's result
    1472             :      * underflowing to zero (in which case "sel" probably has as well).
    1473             :      */
    1474        2144 :     if (fixed_prefix_len > 0)
    1475             :     {
    1476        1554 :         double      prefixsel = pow(FIXED_CHAR_SEL, fixed_prefix_len);
    1477             : 
    1478        1554 :         if (prefixsel > 0.0)
    1479        1554 :             sel /= prefixsel;
    1480             :     }
    1481             : 
    1482             :     /* Make sure result stays in range */
    1483        2144 :     CLAMP_PROBABILITY(sel);
    1484        2144 :     return sel;
    1485             : }
    1486             : 
    1487             : /*
    1488             :  * Check whether char is a letter (and, hence, subject to case-folding)
    1489             :  *
    1490             :  * In multibyte character sets or with ICU, we can't use isalpha, and it does
    1491             :  * not seem worth trying to convert to wchar_t to use iswalpha or u_isalpha.
    1492             :  * Instead, just assume any non-ASCII char is potentially case-varying, and
    1493             :  * hard-wire knowledge of which ASCII chars are letters.
    1494             :  */
    1495             : static int
    1496         270 : pattern_char_isalpha(char c, bool is_multibyte,
    1497             :                      pg_locale_t locale)
    1498             : {
    1499         270 :     if (locale->ctype_is_c)
    1500         144 :         return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
    1501         126 :     else if (is_multibyte && IS_HIGHBIT_SET(c))
    1502           0 :         return true;
    1503         126 :     else if (locale->provider == COLLPROVIDER_ICU)
    1504         126 :         return IS_HIGHBIT_SET(c) ||
    1505         252 :             (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
    1506           0 :     else if (locale->provider == COLLPROVIDER_LIBC)
    1507           0 :         return isalpha_l((unsigned char) c, locale->info.lt);
    1508             :     else
    1509           0 :         return isalpha((unsigned char) c);
    1510             : }
    1511             : 
    1512             : 
    1513             : /*
    1514             :  * For bytea, the increment function need only increment the current byte
    1515             :  * (there are no multibyte characters to worry about).
    1516             :  */
    1517             : static bool
    1518           0 : byte_increment(unsigned char *ptr, int len)
    1519             : {
    1520           0 :     if (*ptr >= 255)
    1521           0 :         return false;
    1522           0 :     (*ptr)++;
    1523           0 :     return true;
    1524             : }
    1525             : 
    1526             : /*
    1527             :  * Try to generate a string greater than the given string or any
    1528             :  * string it is a prefix of.  If successful, return a palloc'd string
    1529             :  * in the form of a Const node; else return NULL.
    1530             :  *
    1531             :  * The caller must provide the appropriate "less than" comparison function
    1532             :  * for testing the strings, along with the collation to use.
    1533             :  *
    1534             :  * The key requirement here is that given a prefix string, say "foo",
    1535             :  * we must be able to generate another string "fop" that is greater than
    1536             :  * all strings "foobar" starting with "foo".  We can test that we have
    1537             :  * generated a string greater than the prefix string, but in non-C collations
    1538             :  * that is not a bulletproof guarantee that an extension of the string might
    1539             :  * not sort after it; an example is that "foo " is less than "foo!", but it
    1540             :  * is not clear that a "dictionary" sort ordering will consider "foo!" less
    1541             :  * than "foo bar".  CAUTION: Therefore, this function should be used only for
    1542             :  * estimation purposes when working in a non-C collation.
    1543             :  *
    1544             :  * To try to catch most cases where an extended string might otherwise sort
    1545             :  * before the result value, we determine which of the strings "Z", "z", "y",
    1546             :  * and "9" is seen as largest by the collation, and append that to the given
    1547             :  * prefix before trying to find a string that compares as larger.
    1548             :  *
    1549             :  * To search for a greater string, we repeatedly "increment" the rightmost
    1550             :  * character, using an encoding-specific character incrementer function.
    1551             :  * When it's no longer possible to increment the last character, we truncate
    1552             :  * off that character and start incrementing the next-to-rightmost.
    1553             :  * For example, if "z" were the last character in the sort order, then we
    1554             :  * could produce "foo" as a string greater than "fonz".
    1555             :  *
    1556             :  * This could be rather slow in the worst case, but in most cases we
    1557             :  * won't have to try more than one or two strings before succeeding.
    1558             :  *
    1559             :  * Note that it's important for the character incrementer not to be too anal
    1560             :  * about producing every possible character code, since in some cases the only
    1561             :  * way to get a larger string is to increment a previous character position.
    1562             :  * So we don't want to spend too much time trying every possible character
    1563             :  * code at the last position.  A good rule of thumb is to be sure that we
    1564             :  * don't try more than 256*K values for a K-byte character (and definitely
    1565             :  * not 256^K, which is what an exhaustive search would approach).
    1566             :  */
    1567             : static Const *
    1568        2446 : make_greater_string(const Const *str_const, FmgrInfo *ltproc, Oid collation)
    1569             : {
    1570        2446 :     Oid         datatype = str_const->consttype;
    1571             :     char       *workstr;
    1572             :     int         len;
    1573             :     Datum       cmpstr;
    1574        2446 :     char       *cmptxt = NULL;
    1575             :     mbcharacter_incrementer charinc;
    1576             : 
    1577             :     /*
    1578             :      * Get a modifiable copy of the prefix string in C-string format, and set
    1579             :      * up the string we will compare to as a Datum.  In C locale this can just
    1580             :      * be the given prefix string, otherwise we need to add a suffix.  Type
    1581             :      * BYTEA sorts bytewise so it never needs a suffix either.
    1582             :      */
    1583        2446 :     if (datatype == BYTEAOID)
    1584             :     {
    1585           0 :         bytea      *bstr = DatumGetByteaPP(str_const->constvalue);
    1586             : 
    1587           0 :         len = VARSIZE_ANY_EXHDR(bstr);
    1588           0 :         workstr = (char *) palloc(len);
    1589           0 :         memcpy(workstr, VARDATA_ANY(bstr), len);
    1590             :         Assert((Pointer) bstr == DatumGetPointer(str_const->constvalue));
    1591           0 :         cmpstr = str_const->constvalue;
    1592             :     }
    1593             :     else
    1594             :     {
    1595        2446 :         if (datatype == NAMEOID)
    1596           0 :             workstr = DatumGetCString(DirectFunctionCall1(nameout,
    1597             :                                                           str_const->constvalue));
    1598             :         else
    1599        2446 :             workstr = TextDatumGetCString(str_const->constvalue);
    1600        2446 :         len = strlen(workstr);
    1601        2446 :         if (len == 0 || pg_newlocale_from_collation(collation)->collate_is_c)
    1602        2420 :             cmpstr = str_const->constvalue;
    1603             :         else
    1604             :         {
    1605             :             /* If first time through, determine the suffix to use */
    1606             :             static char suffixchar = 0;
    1607             :             static Oid  suffixcollation = 0;
    1608             : 
    1609          26 :             if (!suffixchar || suffixcollation != collation)
    1610             :             {
    1611             :                 char       *best;
    1612             : 
    1613           6 :                 best = "Z";
    1614           6 :                 if (varstr_cmp(best, 1, "z", 1, collation) < 0)
    1615           0 :                     best = "z";
    1616           6 :                 if (varstr_cmp(best, 1, "y", 1, collation) < 0)
    1617           0 :                     best = "y";
    1618           6 :                 if (varstr_cmp(best, 1, "9", 1, collation) < 0)
    1619           0 :                     best = "9";
    1620           6 :                 suffixchar = *best;
    1621           6 :                 suffixcollation = collation;
    1622             :             }
    1623             : 
    1624             :             /* And build the string to compare to */
    1625          26 :             if (datatype == NAMEOID)
    1626             :             {
    1627           0 :                 cmptxt = palloc(len + 2);
    1628           0 :                 memcpy(cmptxt, workstr, len);
    1629           0 :                 cmptxt[len] = suffixchar;
    1630           0 :                 cmptxt[len + 1] = '\0';
    1631           0 :                 cmpstr = PointerGetDatum(cmptxt);
    1632             :             }
    1633             :             else
    1634             :             {
    1635          26 :                 cmptxt = palloc(VARHDRSZ + len + 1);
    1636          26 :                 SET_VARSIZE(cmptxt, VARHDRSZ + len + 1);
    1637          26 :                 memcpy(VARDATA(cmptxt), workstr, len);
    1638          26 :                 *(VARDATA(cmptxt) + len) = suffixchar;
    1639          26 :                 cmpstr = PointerGetDatum(cmptxt);
    1640             :             }
    1641             :         }
    1642             :     }
    1643             : 
    1644             :     /* Select appropriate character-incrementer function */
    1645        2446 :     if (datatype == BYTEAOID)
    1646           0 :         charinc = byte_increment;
    1647             :     else
    1648        2446 :         charinc = pg_database_encoding_character_incrementer();
    1649             : 
    1650             :     /* And search ... */
    1651        2446 :     while (len > 0)
    1652             :     {
    1653             :         int         charlen;
    1654             :         unsigned char *lastchar;
    1655             : 
    1656             :         /* Identify the last character --- for bytea, just the last byte */
    1657        2446 :         if (datatype == BYTEAOID)
    1658           0 :             charlen = 1;
    1659             :         else
    1660        2446 :             charlen = len - pg_mbcliplen(workstr, len, len - 1);
    1661        2446 :         lastchar = (unsigned char *) (workstr + len - charlen);
    1662             : 
    1663             :         /*
    1664             :          * Try to generate a larger string by incrementing the last character
    1665             :          * (for BYTEA, we treat each byte as a character).
    1666             :          *
    1667             :          * Note: the incrementer function is expected to return true if it's
    1668             :          * generated a valid-per-the-encoding new character, otherwise false.
    1669             :          * The contents of the character on false return are unspecified.
    1670             :          */
    1671        2446 :         while (charinc(lastchar, charlen))
    1672             :         {
    1673             :             Const      *workstr_const;
    1674             : 
    1675        2446 :             if (datatype == BYTEAOID)
    1676           0 :                 workstr_const = string_to_bytea_const(workstr, len);
    1677             :             else
    1678        2446 :                 workstr_const = string_to_const(workstr, datatype);
    1679             : 
    1680        2446 :             if (DatumGetBool(FunctionCall2Coll(ltproc,
    1681             :                                                collation,
    1682             :                                                cmpstr,
    1683             :                                                workstr_const->constvalue)))
    1684             :             {
    1685             :                 /* Successfully made a string larger than cmpstr */
    1686        2446 :                 if (cmptxt)
    1687          26 :                     pfree(cmptxt);
    1688        2446 :                 pfree(workstr);
    1689        2446 :                 return workstr_const;
    1690             :             }
    1691             : 
    1692             :             /* No good, release unusable value and try again */
    1693           0 :             pfree(DatumGetPointer(workstr_const->constvalue));
    1694           0 :             pfree(workstr_const);
    1695             :         }
    1696             : 
    1697             :         /*
    1698             :          * No luck here, so truncate off the last character and try to
    1699             :          * increment the next one.
    1700             :          */
    1701           0 :         len -= charlen;
    1702           0 :         workstr[len] = '\0';
    1703             :     }
    1704             : 
    1705             :     /* Failed... */
    1706           0 :     if (cmptxt)
    1707           0 :         pfree(cmptxt);
    1708           0 :     pfree(workstr);
    1709             : 
    1710           0 :     return NULL;
    1711             : }
    1712             : 
    1713             : /*
    1714             :  * Generate a Datum of the appropriate type from a C string.
    1715             :  * Note that all of the supported types are pass-by-ref, so the
    1716             :  * returned value should be pfree'd if no longer needed.
    1717             :  */
    1718             : static Datum
    1719       18436 : string_to_datum(const char *str, Oid datatype)
    1720             : {
    1721             :     Assert(str != NULL);
    1722             : 
    1723             :     /*
    1724             :      * We cheat a little by assuming that CStringGetTextDatum() will do for
    1725             :      * bpchar and varchar constants too...
    1726             :      */
    1727       18436 :     if (datatype == NAMEOID)
    1728           0 :         return DirectFunctionCall1(namein, CStringGetDatum(str));
    1729       18436 :     else if (datatype == BYTEAOID)
    1730           0 :         return DirectFunctionCall1(byteain, CStringGetDatum(str));
    1731             :     else
    1732       18436 :         return CStringGetTextDatum(str);
    1733             : }
    1734             : 
    1735             : /*
    1736             :  * Generate a Const node of the appropriate type from a C string.
    1737             :  */
    1738             : static Const *
    1739       18436 : string_to_const(const char *str, Oid datatype)
    1740             : {
    1741       18436 :     Datum       conval = string_to_datum(str, datatype);
    1742             :     Oid         collation;
    1743             :     int         constlen;
    1744             : 
    1745             :     /*
    1746             :      * We only need to support a few datatypes here, so hard-wire properties
    1747             :      * instead of incurring the expense of catalog lookups.
    1748             :      */
    1749       18436 :     switch (datatype)
    1750             :     {
    1751       18436 :         case TEXTOID:
    1752             :         case VARCHAROID:
    1753             :         case BPCHAROID:
    1754       18436 :             collation = DEFAULT_COLLATION_OID;
    1755       18436 :             constlen = -1;
    1756       18436 :             break;
    1757             : 
    1758           0 :         case NAMEOID:
    1759           0 :             collation = C_COLLATION_OID;
    1760           0 :             constlen = NAMEDATALEN;
    1761           0 :             break;
    1762             : 
    1763           0 :         case BYTEAOID:
    1764           0 :             collation = InvalidOid;
    1765           0 :             constlen = -1;
    1766           0 :             break;
    1767             : 
    1768           0 :         default:
    1769           0 :             elog(ERROR, "unexpected datatype in string_to_const: %u",
    1770             :                  datatype);
    1771             :             return NULL;
    1772             :     }
    1773             : 
    1774       18436 :     return makeConst(datatype, -1, collation, constlen,
    1775             :                      conval, false, false);
    1776             : }
    1777             : 
    1778             : /*
    1779             :  * Generate a Const node of bytea type from a binary C string and a length.
    1780             :  */
    1781             : static Const *
    1782          12 : string_to_bytea_const(const char *str, size_t str_len)
    1783             : {
    1784          12 :     bytea      *bstr = palloc(VARHDRSZ + str_len);
    1785             :     Datum       conval;
    1786             : 
    1787          12 :     memcpy(VARDATA(bstr), str, str_len);
    1788          12 :     SET_VARSIZE(bstr, VARHDRSZ + str_len);
    1789          12 :     conval = PointerGetDatum(bstr);
    1790             : 
    1791          12 :     return makeConst(BYTEAOID, -1, InvalidOid, -1, conval, false, false);
    1792             : }

Generated by: LCOV version 1.14