quoted identifier parsing

Author: serprex

test/expected/binary_queries_6.out

@@ -124,7 +124,7 @@ SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1;  -- should work
 
 ALTER SERVER binary_queries_loopback OPTIONS (SET dbname 'no such database');
 SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1;  -- should fail
-ERROR:  pg_clickhouse: DB::Exception: Database `no such database` doesn't exist
+ERROR:  pg_clickhouse: connection error: DB::Exception: Database `no such database` doesn't exist
 ALTER USER MAPPING FOR CURRENT_USER SERVER binary_queries_loopback OPTIONS (ADD user 'no such user');
 SELECT c3, c4 FROM ft1 ORDER BY c3, c1 LIMIT 1;  -- should fail
 ERROR:  pg_clickhouse: connection error: DB::Exception: no such user: Authentication failed: password is incorrect, or there is no user with such name.

vendor/clickhouse-c/clickhouse.h

@@ -527,6 +527,36 @@ chc__strdup(const chc_alloc *al, const char *s, size_t n, chc_err *err)
     return p;
 }
 
+/* Copy a quoted identifier body (between the outer quote chars), resolving
+ * the two escape forms ClickHouse's lexer accepts: a doubled quote stands
+ * for one literal quote (`` `` `` -> `` ` ``, `""` -> `"`), & `\X` keeps X
+ * verbatim. n is an upper bound; the resolved length is returned via
+ * *out_len. */
+static char *
+chc__strdup_unquote(const chc_alloc *al, const char *s, size_t n, char quote,
+                    size_t *out_len, chc_err *err)
+{
+    char *p = chc__alloc(al, n + 1, err);
+    if (!p) return NULL;
+    size_t o = 0;
+    for (size_t i = 0; i < n; i++) {
+        char c = s[i];
+        if (c == '\\' && i + 1 < n) {
+            p[o++] = s[++i];
+            continue;
+        }
+        if (c == quote && i + 1 < n && s[i + 1] == quote) {
+            p[o++] = quote;
+            i++;
+            continue;
+        }
+        p[o++] = c;
+    }
+    p[o] = '\0';
+    *out_len = o;
+    return p;
+}
+
 #ifdef CHC_PROVIDE_STDLIB_ALLOC
 #include <stdlib.h>
 static void *chc__std_alloc(void *ud, size_t n)
@@ -852,6 +882,10 @@ typedef struct {
     chc__tok_kind kind;
     const char   *start;
     size_t        len;
+    /* For CHC__TOK_NAME: 0 = bare identifier; '`' or '"' = quoted, & start/len
+     * span the body between the outer quotes (still raw -- doubled-quote &
+     * backslash escapes are resolved when copied out). */
+    char          quote;
 } chc__tok;
 
 typedef struct {
@@ -867,37 +901,65 @@ chc__next_tok(chc__lex *lx)
         char c = *lx->cur;
         if (c == ' ' || c == '\t' || c == '\n' || c == '\r') { lx->cur++; continue; }
         const char *st = lx->cur;
-        if (c == '(') { lx->cur++; return (chc__tok){CHC__TOK_LPAREN, st, 1}; }
-        if (c == ')') { lx->cur++; return (chc__tok){CHC__TOK_RPAREN, st, 1}; }
-        if (c == ',') { lx->cur++; return (chc__tok){CHC__TOK_COMMA, st, 1}; }
-        if (c == '=') { lx->cur++; return (chc__tok){CHC__TOK_EQ, st, 1}; }
+        if (c == '(') { lx->cur++; return (chc__tok){CHC__TOK_LPAREN, st, 1, 0}; }
+        if (c == ')') { lx->cur++; return (chc__tok){CHC__TOK_RPAREN, st, 1, 0}; }
+        if (c == ',') { lx->cur++; return (chc__tok){CHC__TOK_COMMA, st, 1, 0}; }
+        if (c == '=') { lx->cur++; return (chc__tok){CHC__TOK_EQ, st, 1, 0}; }
         if (c == '\'') {
             /* single-quoted string; clickhouse-cpp does not escape, so we
              * accept anything up to the next unescaped quote. */
             lx->cur++;
             const char *body = lx->cur;
             while (lx->cur < lx->end && *lx->cur != '\'') lx->cur++;
-            if (lx->cur >= lx->end) return (chc__tok){CHC__TOK_INVALID, st, 0};
+            if (lx->cur >= lx->end) return (chc__tok){CHC__TOK_INVALID, st, 0, 0};
             size_t blen = (size_t) (lx->cur - body);
             lx->cur++;                                     /* eat closing ' */
-            return (chc__tok){CHC__TOK_STRING, body, blen};
+            return (chc__tok){CHC__TOK_STRING, body, blen, 0};
+        }
+        if (c == '`' || c == '"') {
+            /* Quoted identifier, matching ClickHouse Lexer.cpp `quotedString`:
+             * doubled quote (`` `` `` or `""`) & backslash-escapes are skipped
+             * during scanning, resolved at copy time. */
+            char q = c;
+            lx->cur++;
+            const char *body = lx->cur;
+            while (lx->cur < lx->end) {
+                char d = *lx->cur;
+                if (d == '\\') {
+                    lx->cur++;
+                    if (lx->cur < lx->end) lx->cur++;
+                    continue;
+                }
+                if (d == q) {
+                    if (lx->cur + 1 < lx->end && lx->cur[1] == q) {
+                        lx->cur += 2;
+                        continue;
+                    }
+                    break;
+                }
+                lx->cur++;
+            }
+            if (lx->cur >= lx->end) return (chc__tok){CHC__TOK_INVALID, st, 0, 0};
+            size_t blen = (size_t) (lx->cur - body);
+            lx->cur++;                                     /* eat closing quote */
+            return (chc__tok){CHC__TOK_NAME, body, blen, q};
         }
         if (isalpha((unsigned char) c) || c == '_') {
             while (lx->cur < lx->end) {
                 char d = *lx->cur;
                 if (!(isalnum((unsigned char) d) || d == '_')) break;
                 lx->cur++;
             }
-            return (chc__tok){CHC__TOK_NAME, st, (size_t) (lx->cur - st)};
+            return (chc__tok){CHC__TOK_NAME, st, (size_t) (lx->cur - st), 0};
         }
         if (isdigit((unsigned char) c) || c == '-') {
             lx->cur++;
             while (lx->cur < lx->end && isdigit((unsigned char) *lx->cur)) lx->cur++;
-            return (chc__tok){CHC__TOK_NUMBER, st, (size_t) (lx->cur - st)};
+            return (chc__tok){CHC__TOK_NUMBER, st, (size_t) (lx->cur - st), 0};
         }
-        return (chc__tok){CHC__TOK_INVALID, st, 0};
+        return (chc__tok){CHC__TOK_INVALID, st, 0, 0};
     }
-    return (chc__tok){CHC__TOK_EOS, lx->end, 0};
+    return (chc__tok){CHC__TOK_EOS, lx->end, 0, 0};
 }
 
 static chc__tok
@@ -1255,7 +1317,7 @@ chc__parse_type(chc__lex *lx, const chc_alloc *al,
                 chc_type **out, chc_err *err)
 {
     chc__tok head = chc__eat_tok(lx);
-    if (head.kind != CHC__TOK_NAME)
+    if (head.kind != CHC__TOK_NAME || head.quote)
         return chc__err_set(err, CHC_ERR_TYPE, "expected type name");
 
     chc_type *t = chc__calloc(al, sizeof *t, err);
@@ -1397,19 +1459,26 @@ chc__parse_type(chc__lex *lx, const chc_alloc *al,
                 bool has_field = false;
                 if (is_tuple && la.kind == CHC__TOK_NAME) {
                     chc__eat_tok(lx);
-                    chc__tok la2 = chc__peek_tok(lx);
-                    if (la2.kind == CHC__TOK_NAME) {
-                        /* `la` is a field-name; `la2` starts the type. */
+                    if (la.quote) {
+                        /* `\`x\`` or `"x"` is never a type head, so it must be
+                         * the field label. */
                         field = la;
                         has_field = true;
                     } else {
-                        /* `la` was the type's leading NAME (terminal or
-                         * parametric like `Tuple(LowCardinality(...))`).
-                         * Put it back & rewind cur to la2's start so the
-                         * next peek re-lexes la2. */
-                        lx->peeked   = la;
-                        lx->has_peek = true;
-                        lx->cur      = la2.start;
+                        chc__tok la2 = chc__peek_tok(lx);
+                        if (la2.kind == CHC__TOK_NAME) {
+                            /* `la` is a field-name; `la2` starts the type. */
+                            field = la;
+                            has_field = true;
+                        } else {
+                            /* `la` was the type's leading NAME (terminal or
+                             * parametric like `Tuple(LowCardinality(...))`).
+                             * Put it back & rewind cur to la2's start so the
+                             * next peek re-lexes la2. */
+                            lx->peeked   = la;
+                            lx->has_peek = true;
+                            lx->cur      = la2.start;
+                        }
                     }
                 }
 
@@ -1450,15 +1519,22 @@ chc__parse_type(chc__lex *lx, const chc_alloc *al,
                     fn_lens[fn_cap] = 0;
                     fn_cap = new_cap;
                     if (has_field) {
-                        fn_buf[fn_cap - 1] = chc__strdup(al, field.start, field.len, err);
+                        size_t flen = field.len;
+                        if (field.quote)
+                            fn_buf[fn_cap - 1] = chc__strdup_unquote(al, field.start,
+                                                                     field.len, field.quote,
+                                                                     &flen, err);
+                        else
+                            fn_buf[fn_cap - 1] = chc__strdup(al, field.start,
+                                                             field.len, err);
                         if (!fn_buf[fn_cap - 1]) {
                             for (size_t i = 0; i < fn_cap - 1; i++)
                                 if (fn_buf[i]) al->free(al->ud, fn_buf[i], fn_lens[i] + 1);
                             al->free(al->ud, fn_buf,  fn_cap * sizeof *fn_buf);
                             al->free(al->ud, fn_lens, fn_cap * sizeof *fn_lens);
                             chc_type_destroy(t, al); return CHC_ERR_OOM;
                         }
-                        fn_lens[fn_cap - 1] = field.len;
+                        fn_lens[fn_cap - 1] = flen;
                         any_named = true;
                     }
                 }