Improve selectivity estimation involving string constants: pay attention

to more than one character, and try to do the right thing in non-ASCII
locales.

diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index 61ff43b3e98ac58b853a6350ad32d5ccc163d14e..af7a449f6975af8b1839a4433d76e919c0ef8901 100644 (file)
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.60 2000/03/20 15:42:46 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.61 2000/03/23 00:55:42 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -48,6 +48,8 @@
 /* default selectivity estimate for inequalities such as "A < b" */
 #define DEFAULT_INEQ_SEL  (1.0 / 3.0)
 
+static bool convert_string_to_scalar(char *str, int strlength,
+                                    double *scaleval);
 static void getattproperties(Oid relid, AttrNumber attnum,
                             Oid *typid,
                             int *typlen,
@@ -472,9 +474,8 @@ scalargtjoinsel(Oid opid,
  * All numeric datatypes are simply converted to their equivalent
  * "double" values.
  *
- * String datatypes are converted to a crude scale using their first character
- * (only if it is in the ASCII range, to try to avoid problems with non-ASCII
- * collating sequences).
+ * String datatypes are converted by convert_string_to_scalar(),
+ * which is explained below.
  *
  * The several datatypes representing absolute times are all converted
  * to Timestamp, which is actually a double, and then we just use that
@@ -525,40 +526,25 @@ convert_to_scalar(Datum value, Oid typid,
         */
        case CHAROID:
        {
-           char        ch = DatumGetChar(value);
+           char    ch = DatumGetChar(value);
 
-           if (ch >= 0 && ch < 127)
-           {
-               *scaleval = (double) ch;
-               return true;
-           }
-           break;
+           return convert_string_to_scalar(&ch, 1, scaleval);
        }
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID:
-           if (VARSIZE(DatumGetPointer(value)) > VARHDRSZ)
-           {
-               char    ch = * (char *) VARDATA(DatumGetPointer(value));
+       {
+           char   *str = (char *) VARDATA(DatumGetPointer(value));
+           int     strlength = VARSIZE(DatumGetPointer(value)) - VARHDRSZ;
 
-               if (ch >= 0 && ch < 127)
-               {
-                   *scaleval = (double) ch;
-                   return true;
-               }
-           }
-           break;
+           return convert_string_to_scalar(str, strlength, scaleval);
+       }
        case NAMEOID:
        {
            NameData   *nm = (NameData *) DatumGetPointer(value);
-           char        ch = NameStr(*nm)[0];
 
-           if (ch >= 0 && ch < 127)
-           {
-               *scaleval = (double) ch;
-               return true;
-           }
-           break;
+           return convert_string_to_scalar(NameStr(*nm), strlen(NameStr(*nm)),
+                                           scaleval);
        }
 
        /*
@@ -644,6 +630,88 @@ convert_to_scalar(Datum value, Oid typid,
    return false;
 }
 
+/*
+ * Do convert_to_scalar()'s work for any character-string data type.
+ *
+ * String datatypes are converted to a scale that ranges from 0 to 1, where
+ * we visualize the bytes of the string as fractional base-256 digits.
+ * It's sufficient to consider the first few bytes, since double has only
+ * limited precision (and we can't expect huge accuracy in our selectivity
+ * predictions anyway!)
+ *
+ * If USE_LOCALE is defined, we must pass the string through strxfrm()
+ * before doing the computation, so as to generate correct locale-specific
+ * results.
+ */
+static bool
+convert_string_to_scalar(char *str, int strlength,
+                        double *scaleval)
+{
+   unsigned char   *sptr;
+   int             slen;
+#ifdef USE_LOCALE
+   char           *rawstr;
+   char           *xfrmstr;
+   size_t          xfrmsize;
+   size_t          xfrmlen;
+#endif
+   double          num,
+                   denom;
+
+   if (strlength <= 0)
+   {
+       *scaleval = 0;          /* empty string has scalar value 0 */
+       return true;
+   }
+
+#ifdef USE_LOCALE
+   /* Need a null-terminated string to pass to strxfrm() */
+   rawstr = (char *) palloc(strlength + 1);
+   memcpy(rawstr, str, strlength);
+   rawstr[strlength] = '\0';
+
+   /* Guess that transformed string is not much bigger */
+   xfrmsize = strlength + 32;  /* arbitrary pad value here... */
+   xfrmstr = (char *) palloc(xfrmsize);
+   xfrmlen = strxfrm(xfrmstr, rawstr, xfrmsize);
+   if (xfrmlen >= xfrmsize)
+   {
+       /* Oops, didn't make it */
+       pfree(xfrmstr);
+       xfrmstr = (char *) palloc(xfrmlen+1);
+       xfrmlen = strxfrm(xfrmstr, rawstr, xfrmlen+1);
+   }
+   pfree(rawstr);
+
+   sptr = (unsigned char *) xfrmstr;
+   slen = xfrmlen;
+#else
+   sptr = (unsigned char *) str;
+   slen = strlength;
+#endif
+
+   /* No need to consider more than about 8 bytes (sizeof double) */
+   if (slen > 8)
+       slen = 8;
+
+   /* Convert initial characters to fraction */
+   num = 0.0;
+   denom = 256.0;
+   while (slen-- > 0)
+   {
+       num += ((double) (*sptr++)) / denom;
+       denom *= 256.0;
+   }
+
+#ifdef USE_LOCALE
+   pfree(xfrmstr);
+#endif
+
+   *scaleval = num;
+   return true;
+}
+
+
 /*
  * getattproperties
  *   Retrieve pg_attribute properties for an attribute,