feat: add relaxed quoting for qualified name tails

PostgreSQL's grammar accepts all keyword categories (including RESERVED_KEYWORD)
in qualified name positions (after a dot). This change adds a new
quoteIdentifierQualifiedTail() method that only quotes for lexical reasons
(uppercase, special characters, leading digits) not for keyword reasons.

This allows the deparser to emit:
- faker.float instead of faker."float"
- myschema.select instead of myschema."select"
- t.from instead of t."from"

while still correctly quoting unqualified identifiers that are keywords.

Empirically verified with libpg-query that all keyword categories parse
successfully in qualified positions across DDL and DML contexts.

Author: pyramation

packages/deparser/src/deparser.ts

@@ -1317,7 +1317,7 @@ export class Deparser implements DeparserVisitor {
       if (node.indirection && node.indirection.length > 0) {
         const indirectionStrs = ListUtils.unwrapList(node.indirection).map(item => {
           if (item.String) {
-            return `.${QuoteUtils.quoteIdentifier(item.String.sval || item.String.str)}`;
+            return `.${QuoteUtils.quoteIdentifierQualifiedTail(item.String.sval || item.String.str)}`;
           }
           return this.visit(item, context);
         });
@@ -1335,7 +1335,7 @@ export class Deparser implements DeparserVisitor {
       if (node.indirection && node.indirection.length > 0) {
         const indirectionStrs = ListUtils.unwrapList(node.indirection).map(item => {
           if (item.String) {
-            return `.${QuoteUtils.quoteIdentifier(item.String.sval || item.String.str)}`;
+            return `.${QuoteUtils.quoteIdentifierQualifiedTail(item.String.sval || item.String.str)}`;
           }
           return this.visit(item, context);
         });
@@ -2018,9 +2018,9 @@ export class Deparser implements DeparserVisitor {
     if (node.catalogname) {
       tableName = QuoteUtils.quoteIdentifier(node.catalogname);
       if (node.schemaname) {
-        tableName += '.' + QuoteUtils.quoteIdentifier(node.schemaname);
+        tableName += '.' + QuoteUtils.quoteIdentifierQualifiedTail(node.schemaname);
       }
-      tableName += '.' + QuoteUtils.quoteIdentifier(node.relname);
+      tableName += '.' + QuoteUtils.quoteIdentifierQualifiedTail(node.relname);
     } else if (node.schemaname) {
       tableName = QuoteUtils.quoteQualifiedIdentifier(node.schemaname, node.relname);
     } else {

packages/deparser/src/utils/quote-utils.ts

@@ -104,6 +104,59 @@ export class QuoteUtils {
     return result;
   }
 
+  /**
+   * Quote an identifier for use as a qualified name tail (after a dot).
+   *
+   * In PostgreSQL's grammar, identifiers that appear after a dot (e.g., schema.name,
+   * table.column) are in a more permissive position that accepts all keyword categories
+   * including RESERVED_KEYWORD. This means we only need to quote for lexical reasons
+   * (uppercase, special characters, leading digits) not for keyword reasons.
+   *
+   * Empirically verified: `myschema.select`, `myschema.float`, `t.from` all parse
+   * successfully in PostgreSQL without quotes.
+   */
+  static quoteIdentifierQualifiedTail(ident: string): string {
+    if (!ident) return ident;
+
+    let nquotes = 0;
+    let safe = true;
+
+    const firstChar = ident[0];
+    if (!((firstChar >= 'a' && firstChar <= 'z') || firstChar === '_')) {
+      safe = false;
+    }
+
+    for (let i = 0; i < ident.length; i++) {
+      const ch = ident[i];
+      if ((ch >= 'a' && ch <= 'z') ||
+          (ch >= '0' && ch <= '9') ||
+          (ch === '_')) {
+        // okay
+      } else {
+        safe = false;
+        if (ch === '"') {
+          nquotes++;
+        }
+      }
+    }
+
+    if (safe) {
+      return ident;
+    }
+
+    let result = '"';
+    for (let i = 0; i < ident.length; i++) {
+      const ch = ident[i];
+      if (ch === '"') {
+        result += '"';
+      }
+      result += ch;
+    }
+    result += '"';
+
+    return result;
+  }
+
   /**
    * Quote a possibly-qualified identifier
    *
@@ -112,10 +165,14 @@ export class QuoteUtils {
    *
    * Return a name of the form qualifier.ident, or just ident if qualifier
    * is null/undefined, quoting each component if necessary.
+   *
+   * When a qualifier is present, the tail identifier uses relaxed quoting that
+   * ignores keyword categories, since PostgreSQL's grammar accepts all keywords
+   * in qualified name positions.
    */
   static quoteQualifiedIdentifier(qualifier: string | null | undefined, ident: string): string {
     if (qualifier) {
-      return `${QuoteUtils.quoteIdentifier(qualifier)}.${QuoteUtils.quoteIdentifier(ident)}`;
+      return `${QuoteUtils.quoteIdentifier(qualifier)}.${QuoteUtils.quoteIdentifierQualifiedTail(ident)}`;
     }
     return QuoteUtils.quoteIdentifier(ident);
   }