pgsql-deparser 17.12.2 → 17.14.0

package/utils/quote-utils.js

@@ -1,53 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuoteUtils = void 0;
-const RESERVED_WORDS = new Set([
-    'all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric',
-    'authorization', 'binary', 'both', 'case', 'cast', 'check', 'collate', 'collation',
-    'column', 'concurrently', 'constraint', 'create', 'cross', 'current_catalog',
-    'current_date', 'current_role', 'current_schema', 'current_time', 'current_timestamp',
-    'current_user', 'default', 'deferrable', 'desc', 'distinct', 'do', 'else', 'end',
-    'except', 'false', 'fetch', 'for', 'foreign', 'freeze', 'from', 'full', 'grant',
-    'group', 'having', 'ilike', 'in', 'initially', 'inner', 'intersect', 'into', 'is',
-    'isnull', 'join', 'lateral', 'leading', 'left', 'like', 'limit', 'localtime',
-    'localtimestamp', 'natural', 'not', 'notnull', 'null', 'offset', 'on', 'only',
-    'or', 'order', 'outer', 'overlaps', 'placing', 'primary', 'references', 'returning',
-    'right', 'select', 'session_user', 'similar', 'some', 'symmetric', 'table', 'tablesample',
-    'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using', 'variadic',
-    'verbose', 'when', 'where', 'window', 'with'
-]);
+const kwlist_1 = require("../kwlist");
 class QuoteUtils {
-    static needsQuotes(value) {
-        if (!value || typeof value !== 'string') {
-            return false;
-        }
-        const lowerValue = value.toLowerCase();
-        if (RESERVED_WORDS.has(lowerValue)) {
-            return true;
-        }
-        if (!/^[a-z_][a-z0-9_$]*$/i.test(value)) {
-            return true;
-        }
-        if (value !== value.toLowerCase()) {
-            return true;
-        }
-        return false;
-    }
-    static quote(value) {
-        if (value == null) {
-            return null;
-        }
-        if (Array.isArray(value)) {
-            return value.map(v => this.quote(v));
-        }
-        if (typeof value !== 'string') {
-            return value;
-        }
-        if (this.needsQuotes(value)) {
-            return `"${value}"`;
-        }
-        return value;
-    }
     static escape(literal) {
         return `'${literal.replace(/'/g, "''")}'`;
     }
@@ -81,5 +36,140 @@ class QuoteUtils {
         // unless it's a raw \x... bytea-style literal.
         return !/^\\x[0-9a-fA-F]+$/i.test(value) && value.includes('\\');
     }
+    /**
+     * Quote an identifier only if needed
+     *
+     * This is a TypeScript port of PostgreSQL's quote_identifier() function from ruleutils.c
+     * https://github.com/postgres/postgres/blob/fab5cd3dd1323f9e66efeb676c4bb212ff340204/src/backend/utils/adt/ruleutils.c#L13055-L13137
+     *
+     * Can avoid quoting if ident starts with a lowercase letter or underscore
+     * and contains only lowercase letters, digits, and underscores, *and* is
+     * not any SQL keyword. Otherwise, supply quotes.
+     *
+     * When quotes are needed, embedded double quotes are properly escaped as "".
+     */
+    static quoteIdentifier(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) {
+            // Check for keyword. We quote keywords except for unreserved ones.
+            // (In some cases we could avoid quoting a col_name or type_func_name
+            // keyword, but it seems much harder than it's worth to tell that.)
+            const kwKind = (0, kwlist_1.keywordKindOf)(ident);
+            if (kwKind !== 'NO_KEYWORD' && kwKind !== 'UNRESERVED_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 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 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.quoteIdentifierAfterDot(ident)}`;
+        }
+        return QuoteUtils.quoteIdentifier(ident);
+    }
 }
 exports.QuoteUtils = QuoteUtils;