Avoid code duplication in \crosstabview.

In commit 6f0d6a507 I added a duplicate copy of psqlscanslash's identifier
downcasing code, but actually it's not hard to split that out as a callable
subroutine and avoid the duplication.

diff --git a/src/bin/psql/crosstabview.c b/src/bin/psql/crosstabview.c
index 71abaf3a6fe85b15f7a6507eb1b8a59bf5fcfb27..7685c6e74672f3943106cd3bf3adc158bb5e6625 100644 (file)
--- a/src/bin/psql/crosstabview.c
+++ b/src/bin/psql/crosstabview.c
@@ -12,6 +12,7 @@
 #include "common.h"
 #include "crosstabview.h"
 #include "pqexpbuffer.h"
+#include "psqlscanslash.h"
 #include "settings.h"
 
 
@@ -648,39 +649,14 @@ indexOfColumn(char *arg, const PGresult *res)
    }
    else
    {
-       bool        inquotes = false;
-       char       *cp = arg;
        int         i;
 
        /*
         * Dequote and downcase the column name.  By checking for all-digits
         * before doing this, we can ensure that a quoted name is treated as a
-        * name even if it's all digits.  This transformation should match
-        * what psqlscanslash.l does in OT_SQLID mode.  (XXX ideally we would
-        * let the lexer do this, but then we couldn't tell if the name was
-        * quoted.)
+        * name even if it's all digits.
         */
-       while (*cp)
-       {
-           if (*cp == '"')
-           {
-               if (inquotes && cp[1] == '"')
-               {
-                   /* Keep the first quote, remove the second */
-                   cp++;
-               }
-               inquotes = !inquotes;
-               /* Collapse out quote at *cp */
-               memmove(cp, cp + 1, strlen(cp));
-               /* do not advance cp */
-           }
-           else
-           {
-               if (!inquotes)
-                   *cp = pg_tolower((unsigned char) *cp);
-               cp += PQmblen(cp, pset.encoding);
-           }
-       }
+       dequote_downcase_identifier(arg, true, pset.encoding);
 
        /* Now look for match(es) among res' column names */
        idx = -1;

diff --git a/src/bin/psql/psqlscanslash.h b/src/bin/psql/psqlscanslash.h
index 48553647a905188bf9dbbf265fbeff37a436f9e7..f078f698e85c773d0314909497311739afe13745 100644 (file)
--- a/src/bin/psql/psqlscanslash.h
+++ b/src/bin/psql/psqlscanslash.h
@@ -32,4 +32,6 @@ extern char *psql_scan_slash_option(PsqlScanState state,
 
 extern void psql_scan_slash_command_end(PsqlScanState state);
 
+extern void dequote_downcase_identifier(char *str, bool downcase, int encoding);
+
 #endif   /* PSQLSCANSLASH_H */

diff --git a/src/bin/psql/psqlscanslash.l b/src/bin/psql/psqlscanslash.l
index e3e0db3b2fb50c9389f393a6912d73fe9647956a..90854afeb0e049322d589c45172e1f02b3cef938 100644 (file)
--- a/src/bin/psql/psqlscanslash.l
+++ b/src/bin/psql/psqlscanslash.l
@@ -566,42 +566,15 @@ psql_scan_slash_option(PsqlScanState state,
 
            /*
             * If SQL identifier processing was requested, then we strip out
-            * excess double quotes and downcase unquoted letters.
-            * Doubled double-quotes become output double-quotes, per spec.
-            *
-            * Note that a string like FOO"BAR"BAZ will be converted to
-            * fooBARbaz; this is somewhat inconsistent with the SQL spec,
-            * which would have us parse it as several identifiers.  But
-            * for psql's purposes, we want a string like "foo"."bar" to
-            * be treated as one option, so there's little choice.
+            * excess double quotes and optionally downcase unquoted letters.
             */
            if (type == OT_SQLID || type == OT_SQLIDHACK)
            {
-               bool        inquotes = false;
-               char       *cp = mybuf.data;
-
-               while (*cp)
-               {
-                   if (*cp == '"')
-                   {
-                       if (inquotes && cp[1] == '"')
-                       {
-                           /* Keep the first quote, remove the second */
-                           cp++;
-                       }
-                       inquotes = !inquotes;
-                       /* Collapse out quote at *cp */
-                       memmove(cp, cp + 1, strlen(cp));
-                       mybuf.len--;
-                       /* do not advance cp */
-                   }
-                   else
-                   {
-                       if (!inquotes && type == OT_SQLID)
-                           *cp = pg_tolower((unsigned char) *cp);
-                       cp += PQmblen(cp, state->encoding);
-                   }
-               }
+               dequote_downcase_identifier(mybuf.data,
+                                           (type != OT_SQLIDHACK),
+                                           state->encoding);
+               /* update mybuf.len for possible shortening */
+               mybuf.len = strlen(mybuf.data);
            }
            break;
        case xslashquote:
@@ -667,6 +640,51 @@ psql_scan_slash_command_end(PsqlScanState state)
    psql_scan_reselect_sql_lexer(state);
 }
 
+/*
+ * De-quote and optionally downcase a SQL identifier.
+ *
+ * The string at *str is modified in-place; it can become shorter,
+ * but not longer.
+ *
+ * If downcase is true then non-quoted letters are folded to lower case.
+ * Ideally this behavior will match the backend's downcase_identifier();
+ * but note that it could differ if LC_CTYPE is different in the frontend.
+ *
+ * Note that a string like FOO"BAR"BAZ will be converted to fooBARbaz;
+ * this is somewhat inconsistent with the SQL spec, which would have us
+ * parse it as several identifiers.  But for psql's purposes, we want a
+ * string like "foo"."bar" to be treated as one option, so there's little
+ * choice; this routine doesn't get to change the token boundaries.
+ */
+void
+dequote_downcase_identifier(char *str, bool downcase, int encoding)
+{
+   bool        inquotes = false;
+   char       *cp = str;
+
+   while (*cp)
+   {
+       if (*cp == '"')
+       {
+           if (inquotes && cp[1] == '"')
+           {
+               /* Keep the first quote, remove the second */
+               cp++;
+           }
+           inquotes = !inquotes;
+           /* Collapse out quote at *cp */
+           memmove(cp, cp + 1, strlen(cp));
+           /* do not advance cp */
+       }
+       else
+       {
+           if (downcase && !inquotes)
+               *cp = pg_tolower((unsigned char) *cp);
+           cp += PQmblen(cp, encoding);
+       }
+   }
+}
+
 /*
  * Evaluate a backticked substring of a slash command's argument.
  *