pgsql-deparser 17.13.0 → 17.15.0

package/deparser.js

@@ -1196,7 +1196,7 @@ class Deparser {
             if (node.indirection && node.indirection.length > 0) {
                 const indirectionStrs = list_utils_1.ListUtils.unwrapList(node.indirection).map(item => {
                     if (item.String) {
-                        return `.${quote_utils_1.QuoteUtils.quoteIdentifier(item.String.sval || item.String.str)}`;
+                        return `.${quote_utils_1.QuoteUtils.quoteIdentifierAfterDot(item.String.sval || item.String.str)}`;
                     }
                     return this.visit(item, context);
                 });
@@ -1213,7 +1213,7 @@ class Deparser {
             if (node.indirection && node.indirection.length > 0) {
                 const indirectionStrs = list_utils_1.ListUtils.unwrapList(node.indirection).map(item => {
                     if (item.String) {
-                        return `.${quote_utils_1.QuoteUtils.quoteIdentifier(item.String.sval || item.String.str)}`;
+                        return `.${quote_utils_1.QuoteUtils.quoteIdentifierAfterDot(item.String.sval || item.String.str)}`;
                     }
                     return this.visit(item, context);
                 });
@@ -1295,7 +1295,8 @@ class Deparser {
     FuncCall(node, context) {
         const funcname = list_utils_1.ListUtils.unwrapList(node.funcname);
         const args = list_utils_1.ListUtils.unwrapList(node.args);
-        const name = funcname.map(n => this.visit(n, context)).join('.');
+        const funcnameParts = funcname.map((n) => n.String?.sval || n.String?.str || '').filter((s) => s);
+        const name = quote_utils_1.QuoteUtils.quoteDottedName(funcnameParts);
         // Handle special SQL syntax functions like XMLEXISTS and EXTRACT
         if (node.funcformat === 'COERCE_SQL_SYNTAX' && name === 'pg_catalog.xmlexists' && args.length >= 2) {
             const xpath = this.visit(args[0], context);
@@ -1850,8 +1851,9 @@ class Deparser {
                 return output.join(' ');
             }
         }
-        const quotedNames = names.map((name) => quote_utils_1.QuoteUtils.quoteIdentifier(name));
-        let result = mods(quotedNames.join('.'), args);
+        // Use type-name quoting for non-pg_catalog types
+        // This allows keywords like 'json', 'int', 'boolean' to remain unquoted in type positions
+        let result = mods(quote_utils_1.QuoteUtils.quoteTypeDottedName(names), args);
         if (node.arrayBounds && node.arrayBounds.length > 0) {
             result += formatArrayBounds(node.arrayBounds);
         }
@@ -1891,9 +1893,9 @@ class Deparser {
         if (node.catalogname) {
             tableName = quote_utils_1.QuoteUtils.quoteIdentifier(node.catalogname);
             if (node.schemaname) {
-                tableName += '.' + quote_utils_1.QuoteUtils.quoteIdentifier(node.schemaname);
+                tableName += '.' + quote_utils_1.QuoteUtils.quoteIdentifierAfterDot(node.schemaname);
             }
-            tableName += '.' + quote_utils_1.QuoteUtils.quoteIdentifier(node.relname);
+            tableName += '.' + quote_utils_1.QuoteUtils.quoteIdentifierAfterDot(node.relname);
         }
         else if (node.schemaname) {
             tableName = quote_utils_1.QuoteUtils.quoteQualifiedIdentifier(node.schemaname, node.relname);
@@ -5158,7 +5160,8 @@ class Deparser {
             output.push('FUNCTION');
         }
         if (node.funcname && node.funcname.length > 0) {
-            const funcName = node.funcname.map((name) => this.visit(name, context)).join('.');
+            const funcnameParts = node.funcname.map((name) => name.String?.sval || name.String?.str || '').filter((s) => s);
+            const funcName = quote_utils_1.QuoteUtils.quoteDottedName(funcnameParts);
             if (node.parameters && node.parameters.length > 0) {
                 const params = node.parameters
                     .filter((param) => {

package/esm/deparser.js

@@ -1193,7 +1193,7 @@ export class Deparser {
             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.quoteIdentifierAfterDot(item.String.sval || item.String.str)}`;
                     }
                     return this.visit(item, context);
                 });
@@ -1210,7 +1210,7 @@ export class Deparser {
             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.quoteIdentifierAfterDot(item.String.sval || item.String.str)}`;
                     }
                     return this.visit(item, context);
                 });
@@ -1292,7 +1292,8 @@ export class Deparser {
     FuncCall(node, context) {
         const funcname = ListUtils.unwrapList(node.funcname);
         const args = ListUtils.unwrapList(node.args);
-        const name = funcname.map(n => this.visit(n, context)).join('.');
+        const funcnameParts = funcname.map((n) => n.String?.sval || n.String?.str || '').filter((s) => s);
+        const name = QuoteUtils.quoteDottedName(funcnameParts);
         // Handle special SQL syntax functions like XMLEXISTS and EXTRACT
         if (node.funcformat === 'COERCE_SQL_SYNTAX' && name === 'pg_catalog.xmlexists' && args.length >= 2) {
             const xpath = this.visit(args[0], context);
@@ -1847,8 +1848,9 @@ export class Deparser {
                 return output.join(' ');
             }
         }
-        const quotedNames = names.map((name) => QuoteUtils.quoteIdentifier(name));
-        let result = mods(quotedNames.join('.'), args);
+        // Use type-name quoting for non-pg_catalog types
+        // This allows keywords like 'json', 'int', 'boolean' to remain unquoted in type positions
+        let result = mods(QuoteUtils.quoteTypeDottedName(names), args);
         if (node.arrayBounds && node.arrayBounds.length > 0) {
             result += formatArrayBounds(node.arrayBounds);
         }
@@ -1888,9 +1890,9 @@ export class Deparser {
         if (node.catalogname) {
             tableName = QuoteUtils.quoteIdentifier(node.catalogname);
             if (node.schemaname) {
-                tableName += '.' + QuoteUtils.quoteIdentifier(node.schemaname);
+                tableName += '.' + QuoteUtils.quoteIdentifierAfterDot(node.schemaname);
             }
-            tableName += '.' + QuoteUtils.quoteIdentifier(node.relname);
+            tableName += '.' + QuoteUtils.quoteIdentifierAfterDot(node.relname);
         }
         else if (node.schemaname) {
             tableName = QuoteUtils.quoteQualifiedIdentifier(node.schemaname, node.relname);
@@ -5155,7 +5157,8 @@ export class Deparser {
             output.push('FUNCTION');
         }
         if (node.funcname && node.funcname.length > 0) {
-            const funcName = node.funcname.map((name) => this.visit(name, context)).join('.');
+            const funcnameParts = node.funcname.map((name) => name.String?.sval || name.String?.str || '').filter((s) => s);
+            const funcName = QuoteUtils.quoteDottedName(funcnameParts);
             if (node.parameters && node.parameters.length > 0) {
                 const params = node.parameters
                     .filter((param) => {

package/esm/utils/quote-utils.js

@@ -48,7 +48,6 @@ export class QuoteUtils {
     static quoteIdentifier(ident) {
         if (!ident)
             return ident;
-        let nquotes = 0;
         let safe = true;
         // Check first character: must be lowercase letter or underscore
         const firstChar = ident[0];
@@ -65,9 +64,6 @@ export class QuoteUtils {
             }
             else {
                 safe = false;
-                if (ch === '"') {
-                    nquotes++;
-                }
             }
         }
         if (safe) {
@@ -94,19 +90,151 @@ export class QuoteUtils {
         result += '"';
         return result;
     }
+    /**
+     * Quote an identifier that appears after a dot in a qualified name.
+     *
+     * 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 quoteIdentifierAfterDot(ident) {
+        if (!ident)
+            return ident;
+        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 (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 dotted name (e.g., schema.table, catalog.schema.table).
+     *
+     * The first part uses strict quoting (keywords are quoted), while subsequent
+     * parts use relaxed quoting (keywords allowed, only quote for lexical reasons).
+     *
+     * This reflects PostgreSQL's grammar where the first identifier in a statement
+     * may conflict with keywords, but identifiers after a dot are in a more
+     * permissive position.
+     */
+    static quoteDottedName(parts) {
+        if (!parts || parts.length === 0)
+            return '';
+        if (parts.length === 1) {
+            return QuoteUtils.quoteIdentifier(parts[0]);
+        }
+        return parts.map((part, index) => index === 0 ? QuoteUtils.quoteIdentifier(part) : QuoteUtils.quoteIdentifierAfterDot(part)).join('.');
+    }
     /**
      * Quote a possibly-qualified identifier
      *
-     * This is a TypeScript port of PostgreSQL's quote_qualified_identifier() function from ruleutils.c
-     * https://github.com/postgres/postgres/blob/fab5cd3dd1323f9e66efeb676c4bb212ff340204/src/backend/utils/adt/ruleutils.c#L13139-L13156
+     * This is inspired by PostgreSQL's quote_qualified_identifier() function from ruleutils.c
+     * but uses relaxed quoting for the tail component since PostgreSQL's grammar accepts
+     * all keywords in qualified name positions.
      *
      * Return a name of the form qualifier.ident, or just ident if qualifier
      * is null/undefined, quoting each component if necessary.
      */
     static quoteQualifiedIdentifier(qualifier, ident) {
         if (qualifier) {
-            return `${QuoteUtils.quoteIdentifier(qualifier)}.${QuoteUtils.quoteIdentifier(ident)}`;
+            return `${QuoteUtils.quoteIdentifier(qualifier)}.${QuoteUtils.quoteIdentifierAfterDot(ident)}`;
         }
         return QuoteUtils.quoteIdentifier(ident);
     }
+    /**
+     * Quote an identifier that appears as a type name.
+     *
+     * Type names in PostgreSQL have a less strict quoting policy than standalone identifiers.
+     * In type positions, COL_NAME_KEYWORD and TYPE_FUNC_NAME_KEYWORD are allowed unquoted
+     * (e.g., 'json', 'int', 'boolean', 'interval'). Only RESERVED_KEYWORD must be quoted.
+     *
+     * This is different from:
+     * - quoteIdentifier(): quotes all keywords except UNRESERVED_KEYWORD
+     * - quoteIdentifierAfterDot(): only quotes for lexical reasons (no keyword checking)
+     *
+     * Type names still need quoting for lexical reasons (uppercase, special chars, etc.).
+     */
+    static quoteIdentifierTypeName(ident) {
+        if (!ident)
+            return ident;
+        let safe = true;
+        // Check first character: must be lowercase letter or underscore
+        const firstChar = ident[0];
+        if (!((firstChar >= 'a' && firstChar <= 'z') || firstChar === '_')) {
+            safe = false;
+        }
+        // Check all characters
+        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 (safe) {
+            // For type names, only quote RESERVED_KEYWORD
+            // COL_NAME_KEYWORD and TYPE_FUNC_NAME_KEYWORD are allowed unquoted in type positions
+            const kwKind = keywordKindOf(ident);
+            if (kwKind === 'RESERVED_KEYWORD') {
+                safe = false;
+            }
+        }
+        if (safe) {
+            return ident; // no change needed
+        }
+        // Build quoted identifier with escaped embedded quotes
+        let result = '"';
+        for (let i = 0; i < ident.length; i++) {
+            const ch = ident[i];
+            if (ch === '"') {
+                result += '"'; // escape " as ""
+            }
+            result += ch;
+        }
+        result += '"';
+        return result;
+    }
+    /**
+     * Quote a dotted type name (e.g., schema.typename).
+     *
+     * For type names, we use type-name quoting for all parts since the entire
+     * qualified name is in a type context. This allows keywords like 'json',
+     * 'int', 'boolean' to remain unquoted in user-defined schema-qualified types.
+     */
+    static quoteTypeDottedName(parts) {
+        if (!parts || parts.length === 0)
+            return '';
+        return parts.map(part => QuoteUtils.quoteIdentifierTypeName(part)).join('.');
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-deparser",
-  "version": "17.13.0",
+  "version": "17.15.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostgreSQL AST Deparser",
   "main": "index.js",
@@ -60,5 +60,5 @@
   "dependencies": {
     "@pgsql/types": "^17.6.2"
   },
-  "gitHead": "7cbb9621ab078db873c1627713963ffa98b8447c"
+  "gitHead": "df8eb8b89aee325cd9005599bc2ac67a746aade7"
 }

package/utils/quote-utils.d.ts

@@ -28,14 +28,60 @@ export declare class QuoteUtils {
      * When quotes are needed, embedded double quotes are properly escaped as "".
      */
     static quoteIdentifier(ident: string): string;
+    /**
+     * Quote an identifier that appears after a dot in a qualified name.
+     *
+     * 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 quoteIdentifierAfterDot(ident: string): string;
+    /**
+     * Quote a dotted name (e.g., schema.table, catalog.schema.table).
+     *
+     * The first part uses strict quoting (keywords are quoted), while subsequent
+     * parts use relaxed quoting (keywords allowed, only quote for lexical reasons).
+     *
+     * This reflects PostgreSQL's grammar where the first identifier in a statement
+     * may conflict with keywords, but identifiers after a dot are in a more
+     * permissive position.
+     */
+    static quoteDottedName(parts: string[]): string;
     /**
      * Quote a possibly-qualified identifier
      *
-     * This is a TypeScript port of PostgreSQL's quote_qualified_identifier() function from ruleutils.c
-     * https://github.com/postgres/postgres/blob/fab5cd3dd1323f9e66efeb676c4bb212ff340204/src/backend/utils/adt/ruleutils.c#L13139-L13156
+     * This is inspired by PostgreSQL's quote_qualified_identifier() function from ruleutils.c
+     * but uses relaxed quoting for the tail component since PostgreSQL's grammar accepts
+     * all keywords in qualified name positions.
      *
      * Return a name of the form qualifier.ident, or just ident if qualifier
      * is null/undefined, quoting each component if necessary.
      */
     static quoteQualifiedIdentifier(qualifier: string | null | undefined, ident: string): string;
+    /**
+     * Quote an identifier that appears as a type name.
+     *
+     * Type names in PostgreSQL have a less strict quoting policy than standalone identifiers.
+     * In type positions, COL_NAME_KEYWORD and TYPE_FUNC_NAME_KEYWORD are allowed unquoted
+     * (e.g., 'json', 'int', 'boolean', 'interval'). Only RESERVED_KEYWORD must be quoted.
+     *
+     * This is different from:
+     * - quoteIdentifier(): quotes all keywords except UNRESERVED_KEYWORD
+     * - quoteIdentifierAfterDot(): only quotes for lexical reasons (no keyword checking)
+     *
+     * Type names still need quoting for lexical reasons (uppercase, special chars, etc.).
+     */
+    static quoteIdentifierTypeName(ident: string): string;
+    /**
+     * Quote a dotted type name (e.g., schema.typename).
+     *
+     * For type names, we use type-name quoting for all parts since the entire
+     * qualified name is in a type context. This allows keywords like 'json',
+     * 'int', 'boolean' to remain unquoted in user-defined schema-qualified types.
+     */
+    static quoteTypeDottedName(parts: string[]): string;
 }

package/utils/quote-utils.js

@@ -51,7 +51,6 @@ class QuoteUtils {
     static quoteIdentifier(ident) {
         if (!ident)
             return ident;
-        let nquotes = 0;
         let safe = true;
         // Check first character: must be lowercase letter or underscore
         const firstChar = ident[0];
@@ -68,9 +67,6 @@ class QuoteUtils {
             }
             else {
                 safe = false;
-                if (ch === '"') {
-                    nquotes++;
-                }
             }
         }
         if (safe) {
@@ -97,20 +93,152 @@ class QuoteUtils {
         result += '"';
         return result;
     }
+    /**
+     * Quote an identifier that appears after a dot in a qualified name.
+     *
+     * 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 quoteIdentifierAfterDot(ident) {
+        if (!ident)
+            return ident;
+        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 (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 dotted name (e.g., schema.table, catalog.schema.table).
+     *
+     * The first part uses strict quoting (keywords are quoted), while subsequent
+     * parts use relaxed quoting (keywords allowed, only quote for lexical reasons).
+     *
+     * This reflects PostgreSQL's grammar where the first identifier in a statement
+     * may conflict with keywords, but identifiers after a dot are in a more
+     * permissive position.
+     */
+    static quoteDottedName(parts) {
+        if (!parts || parts.length === 0)
+            return '';
+        if (parts.length === 1) {
+            return QuoteUtils.quoteIdentifier(parts[0]);
+        }
+        return parts.map((part, index) => index === 0 ? QuoteUtils.quoteIdentifier(part) : QuoteUtils.quoteIdentifierAfterDot(part)).join('.');
+    }
     /**
      * Quote a possibly-qualified identifier
      *
-     * This is a TypeScript port of PostgreSQL's quote_qualified_identifier() function from ruleutils.c
-     * https://github.com/postgres/postgres/blob/fab5cd3dd1323f9e66efeb676c4bb212ff340204/src/backend/utils/adt/ruleutils.c#L13139-L13156
+     * This is inspired by PostgreSQL's quote_qualified_identifier() function from ruleutils.c
+     * but uses relaxed quoting for the tail component since PostgreSQL's grammar accepts
+     * all keywords in qualified name positions.
      *
      * Return a name of the form qualifier.ident, or just ident if qualifier
      * is null/undefined, quoting each component if necessary.
      */
     static quoteQualifiedIdentifier(qualifier, ident) {
         if (qualifier) {
-            return `${QuoteUtils.quoteIdentifier(qualifier)}.${QuoteUtils.quoteIdentifier(ident)}`;
+            return `${QuoteUtils.quoteIdentifier(qualifier)}.${QuoteUtils.quoteIdentifierAfterDot(ident)}`;
         }
         return QuoteUtils.quoteIdentifier(ident);
     }
+    /**
+     * Quote an identifier that appears as a type name.
+     *
+     * Type names in PostgreSQL have a less strict quoting policy than standalone identifiers.
+     * In type positions, COL_NAME_KEYWORD and TYPE_FUNC_NAME_KEYWORD are allowed unquoted
+     * (e.g., 'json', 'int', 'boolean', 'interval'). Only RESERVED_KEYWORD must be quoted.
+     *
+     * This is different from:
+     * - quoteIdentifier(): quotes all keywords except UNRESERVED_KEYWORD
+     * - quoteIdentifierAfterDot(): only quotes for lexical reasons (no keyword checking)
+     *
+     * Type names still need quoting for lexical reasons (uppercase, special chars, etc.).
+     */
+    static quoteIdentifierTypeName(ident) {
+        if (!ident)
+            return ident;
+        let safe = true;
+        // Check first character: must be lowercase letter or underscore
+        const firstChar = ident[0];
+        if (!((firstChar >= 'a' && firstChar <= 'z') || firstChar === '_')) {
+            safe = false;
+        }
+        // Check all characters
+        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 (safe) {
+            // For type names, only quote RESERVED_KEYWORD
+            // COL_NAME_KEYWORD and TYPE_FUNC_NAME_KEYWORD are allowed unquoted in type positions
+            const kwKind = (0, kwlist_1.keywordKindOf)(ident);
+            if (kwKind === 'RESERVED_KEYWORD') {
+                safe = false;
+            }
+        }
+        if (safe) {
+            return ident; // no change needed
+        }
+        // Build quoted identifier with escaped embedded quotes
+        let result = '"';
+        for (let i = 0; i < ident.length; i++) {
+            const ch = ident[i];
+            if (ch === '"') {
+                result += '"'; // escape " as ""
+            }
+            result += ch;
+        }
+        result += '"';
+        return result;
+    }
+    /**
+     * Quote a dotted type name (e.g., schema.typename).
+     *
+     * For type names, we use type-name quoting for all parts since the entire
+     * qualified name is in a type context. This allows keywords like 'json',
+     * 'int', 'boolean' to remain unquoted in user-defined schema-qualified types.
+     */
+    static quoteTypeDottedName(parts) {
+        if (!parts || parts.length === 0)
+            return '';
+        return parts.map(part => QuoteUtils.quoteIdentifierTypeName(part)).join('.');
+    }
 }
 exports.QuoteUtils = QuoteUtils;