pgsql-deparser 15.1.0 → 15.2.0

package/deparser/deparser.js

@@ -5,10 +5,29 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deparser = void 0;
-const base_1 = require("./visitors/base");
-const sql_formatter_1 = require("./utils/sql-formatter");
-const quote_utils_1 = require("./utils/quote-utils");
+const quotes_1 = require("@pgsql/quotes");
 const list_utils_1 = require("./utils/list-utils");
+const sql_formatter_1 = require("./utils/sql-formatter");
+const base_1 = require("./visitors/base");
+// WindowDef.frameOptions bit flags (src/include/nodes/parsenodes.h)
+const FRAMEOPTION_NONDEFAULT = 0x00001;
+const FRAMEOPTION_RANGE = 0x00002;
+const FRAMEOPTION_ROWS = 0x00004;
+const FRAMEOPTION_GROUPS = 0x00008;
+const FRAMEOPTION_BETWEEN = 0x00010;
+const FRAMEOPTION_START_UNBOUNDED_PRECEDING = 0x00020;
+const FRAMEOPTION_END_UNBOUNDED_PRECEDING = 0x00040;
+const FRAMEOPTION_START_UNBOUNDED_FOLLOWING = 0x00080;
+const FRAMEOPTION_END_UNBOUNDED_FOLLOWING = 0x00100;
+const FRAMEOPTION_START_CURRENT_ROW = 0x00200;
+const FRAMEOPTION_END_CURRENT_ROW = 0x00400;
+const FRAMEOPTION_START_OFFSET_PRECEDING = 0x00800;
+const FRAMEOPTION_END_OFFSET_PRECEDING = 0x01000;
+const FRAMEOPTION_START_OFFSET_FOLLOWING = 0x02000;
+const FRAMEOPTION_END_OFFSET_FOLLOWING = 0x04000;
+const FRAMEOPTION_EXCLUDE_CURRENT_ROW = 0x08000;
+const FRAMEOPTION_EXCLUDE_GROUP = 0x10000;
+const FRAMEOPTION_EXCLUDE_TIES = 0x20000;
 /**
  * List of real PostgreSQL built-in types as they appear in pg_catalog.pg_type.typname.
  * These are stored in lowercase in PostgreSQL system catalogs.
@@ -107,6 +126,36 @@ function isWrappedParseResult(obj) {
  * The deparser automatically detects bare ParseResult objects for backward
  * compatibility and wraps them internally for consistent processing.
  */
+function formatBitString(bsval) {
+    const quote = (value) => value.replace(/'/g, "''");
+    if (/^x[0-9A-Fa-f]*$/.test(bsval)) {
+        return `x'${bsval.substring(1)}'`;
+    }
+    if (bsval.startsWith('b')) {
+        return `b'${quote(bsval.substring(1))}'`;
+    }
+    return `b'${quote(bsval)}'`;
+}
+// A dollar-quoted body ends at the first occurrence of its tag, including one
+// formed by the body's trailing characters plus the closing tag (`...$` + `$$`).
+function dollarTagConflicts(body, tag) {
+    return (body + tag).indexOf(tag) < body.length;
+}
+const NUMERIC_LITERAL = /^[+-]?(?:0[xX](?:_?[0-9A-Fa-f])+|0[oO](?:_?[0-7])+|0[bB](?:_?[01])+|(?:\d(?:_?\d)*(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?)$/;
+function formatInteger(ival) {
+    const value = String(ival);
+    if (!/^[+-]?\d+$/.test(value)) {
+        throw new Error(`Invalid integer literal: ${value}`);
+    }
+    return value;
+}
+function formatNumeric(fval) {
+    const value = String(fval);
+    if (!NUMERIC_LITERAL.test(value)) {
+        throw new Error(`Invalid numeric literal: ${value}`);
+    }
+    return value;
+}
 class Deparser {
     tree;
     options;
@@ -166,10 +215,133 @@ class Deparser {
      */
     getFunctionDelimiter(body) {
         const delimiter = this.options.functionDelimiter || '$$';
-        if (body.includes(delimiter)) {
-            return this.options.functionDelimiterFallback || '$EOFCODE$';
+        if (!dollarTagConflicts(body, delimiter)) {
+            return delimiter;
+        }
+        const fallback = this.options.functionDelimiterFallback || '$EOFCODE$';
+        if (!dollarTagConflicts(body, fallback)) {
+            return fallback;
+        }
+        const base = fallback.slice(0, -1);
+        let counter = 1;
+        while (dollarTagConflicts(body, `${base}${counter}$`)) {
+            counter++;
+        }
+        return `${base}${counter}$`;
+    }
+    /**
+     * Maps ObjectType enum values to their corresponding SQL keywords
+     * Used by AlterOwnerStmt, AlterObjectSchemaStmt, and other statements that need object type keywords
+     */
+    getObjectTypeKeyword(objectType) {
+        switch (objectType) {
+            case 'OBJECT_TABLE':
+                return 'TABLE';
+            case 'OBJECT_VIEW':
+                return 'VIEW';
+            case 'OBJECT_INDEX':
+                return 'INDEX';
+            case 'OBJECT_SEQUENCE':
+                return 'SEQUENCE';
+            case 'OBJECT_FUNCTION':
+                return 'FUNCTION';
+            case 'OBJECT_PROCEDURE':
+                return 'PROCEDURE';
+            case 'OBJECT_SCHEMA':
+                return 'SCHEMA';
+            case 'OBJECT_DATABASE':
+                return 'DATABASE';
+            case 'OBJECT_DOMAIN':
+                return 'DOMAIN';
+            case 'OBJECT_AGGREGATE':
+                return 'AGGREGATE';
+            case 'OBJECT_CONVERSION':
+                return 'CONVERSION';
+            case 'OBJECT_LANGUAGE':
+                return 'LANGUAGE';
+            case 'OBJECT_OPERATOR':
+                return 'OPERATOR';
+            case 'OBJECT_OPFAMILY':
+                return 'OPERATOR FAMILY';
+            case 'OBJECT_OPCLASS':
+                return 'OPERATOR CLASS';
+            case 'OBJECT_TSDICTIONARY':
+                return 'TEXT SEARCH DICTIONARY';
+            case 'OBJECT_TSCONFIGURATION':
+                return 'TEXT SEARCH CONFIGURATION';
+            case 'OBJECT_EVENT_TRIGGER':
+                return 'EVENT TRIGGER';
+            case 'OBJECT_FDW':
+                return 'FOREIGN DATA WRAPPER';
+            case 'OBJECT_FOREIGN_SERVER':
+                return 'SERVER';
+            case 'OBJECT_TYPE':
+                return 'TYPE';
+            case 'OBJECT_COLLATION':
+                return 'COLLATION';
+            case 'OBJECT_PUBLICATION':
+                return 'PUBLICATION';
+            case 'OBJECT_ACCESS_METHOD':
+                return 'ACCESS METHOD';
+            case 'OBJECT_AMOP':
+                return 'OPERATOR CLASS';
+            case 'OBJECT_AMPROC':
+                return 'OPERATOR CLASS';
+            case 'OBJECT_ATTRIBUTE':
+                return 'ATTRIBUTE';
+            case 'OBJECT_CAST':
+                return 'CAST';
+            case 'OBJECT_COLUMN':
+                return 'COLUMN';
+            case 'OBJECT_DEFAULT':
+                return 'DEFAULT';
+            case 'OBJECT_DEFACL':
+                return 'DEFAULT PRIVILEGES';
+            case 'OBJECT_DOMCONSTRAINT':
+                return 'DOMAIN';
+            case 'OBJECT_EXTENSION':
+                return 'EXTENSION';
+            case 'OBJECT_FOREIGN_TABLE':
+                return 'FOREIGN TABLE';
+            case 'OBJECT_LARGEOBJECT':
+                return 'LARGE OBJECT';
+            case 'OBJECT_MATVIEW':
+                return 'MATERIALIZED VIEW';
+            case 'OBJECT_PARAMETER_ACL':
+                return 'PARAMETER';
+            case 'OBJECT_POLICY':
+                return 'POLICY';
+            case 'OBJECT_PUBLICATION_NAMESPACE':
+                return 'PUBLICATION';
+            case 'OBJECT_PUBLICATION_REL':
+                return 'PUBLICATION';
+            case 'OBJECT_ROLE':
+                return 'ROLE';
+            case 'OBJECT_ROUTINE':
+                return 'ROUTINE';
+            case 'OBJECT_RULE':
+                return 'RULE';
+            case 'OBJECT_STATISTIC_EXT':
+                return 'STATISTICS';
+            case 'OBJECT_SUBSCRIPTION':
+                return 'SUBSCRIPTION';
+            case 'OBJECT_TABCONSTRAINT':
+                return 'CONSTRAINT';
+            case 'OBJECT_TABLESPACE':
+                return 'TABLESPACE';
+            case 'OBJECT_TRANSFORM':
+                return 'TRANSFORM';
+            case 'OBJECT_TRIGGER':
+                return 'TRIGGER';
+            case 'OBJECT_TSPARSER':
+                return 'TEXT SEARCH PARSER';
+            case 'OBJECT_TSTEMPLATE':
+                return 'TEXT SEARCH TEMPLATE';
+            case 'OBJECT_USER_MAPPING':
+                return 'USER MAPPING';
+            default:
+                throw new Error(`Unsupported objectType: ${objectType}`);
         }
-        return delimiter;
     }
     deparse(node, context) {
         if (node == null) {
@@ -332,12 +504,7 @@ class Deparser {
                     // Check if single target is complex - if so, use multiline format
                     if (this.isComplexSelectTarget(targetNode)) {
                         output.push('SELECT' + distinctPart);
-                        if (this.containsMultilineStringLiteral(target)) {
-                            output.push(target);
-                        }
-                        else {
-                            output.push(context.indent(target));
-                        }
+                        output.push(context.indent(target));
                     }
                     else {
                         output.push('SELECT' + distinctPart + ' ' + target);
@@ -347,9 +514,6 @@ class Deparser {
                     const targetStrings = targetList
                         .map(e => {
                         const targetStr = this.visit(e, context.spawn('SelectStmt', { select: true }));
-                        if (this.containsMultilineStringLiteral(targetStr)) {
-                            return targetStr;
-                        }
                         return context.indent(targetStr);
                     });
                     const formattedTargets = targetStrings.join(',' + context.newline());
@@ -401,9 +565,6 @@ class Deparser {
                     return context.parens(values.join(', '));
                 });
                 const indentedTuples = lists.map(tuple => {
-                    if (this.containsMultilineStringLiteral(tuple)) {
-                        return tuple;
-                    }
                     return context.indent(tuple);
                 });
                 output.push(indentedTuples.join(',\n'));
@@ -423,9 +584,6 @@ class Deparser {
                 const groupItems = groupList
                     .map(e => {
                     const groupStr = this.visit(e, context.spawn('SelectStmt', { group: true, indentLevel: context.indentLevel + 1 }));
-                    if (this.containsMultilineStringLiteral(groupStr)) {
-                        return groupStr;
-                    }
                     return context.indent(groupStr);
                 })
                     .join(',' + context.newline());
@@ -444,12 +602,7 @@ class Deparser {
             if (context.isPretty()) {
                 output.push('HAVING');
                 const havingStr = this.visit(node.havingClause, context);
-                if (this.containsMultilineStringLiteral(havingStr)) {
-                    output.push(havingStr);
-                }
-                else {
-                    output.push(context.indent(havingStr));
-                }
+                output.push(context.indent(havingStr));
             }
             else {
                 output.push('HAVING');
@@ -470,9 +623,6 @@ class Deparser {
                 const sortItems = sortList
                     .map(e => {
                     const sortStr = this.visit(e, context.spawn('SelectStmt', { sort: true, indentLevel: context.indentLevel + 1 }));
-                    if (this.containsMultilineStringLiteral(sortStr)) {
-                        return sortStr;
-                    }
                     return context.indent(sortStr);
                 })
                     .join(',' + context.newline());
@@ -548,10 +698,15 @@ class Deparser {
                     return context.format([leftExpr, operator, rightExpr]);
                 }
                 else if (rexpr) {
-                    return context.format([
-                        this.deparseOperatorName(name, context),
-                        this.visit(rexpr, context)
-                    ]);
+                    // Unary operator (e.g., unary minus: - expr)
+                    const operator = this.deparseOperatorName(name, context);
+                    let rightExpr = this.visit(rexpr, context);
+                    // Wrap in parentheses if rexpr is a binary A_Expr to preserve semantics
+                    // e.g., -(a - b) must stay -(a - b), not become -a - b
+                    if (rexpr && 'A_Expr' in rexpr && rexpr.A_Expr?.kind === 'AEXPR_OP' && rexpr.A_Expr?.lexpr) {
+                        rightExpr = context.parens(rightExpr);
+                    }
+                    return context.format([operator, rightExpr]);
                 }
                 break;
             case 'AEXPR_OP_ANY':
@@ -731,15 +886,15 @@ class Deparser {
     getOperatorPrecedence(operator) {
         const precedence = {
             '||': 1, // string concatenation
-            'OR': 2, // logical OR
-            'AND': 3, // logical AND
-            'NOT': 4, // logical NOT
-            'IS': 5, // IS NULL, IS NOT NULL, etc.
-            'IN': 5, // IN, NOT IN
-            'BETWEEN': 5, // BETWEEN, NOT BETWEEN
-            'LIKE': 5, // LIKE, ILIKE, SIMILAR TO
-            'ILIKE': 5,
-            'SIMILAR': 5,
+            OR: 2, // logical OR
+            AND: 3, // logical AND
+            NOT: 4, // logical NOT
+            IS: 5, // IS NULL, IS NOT NULL, etc.
+            IN: 5, // IN, NOT IN
+            BETWEEN: 5, // BETWEEN, NOT BETWEEN
+            LIKE: 5, // LIKE, ILIKE, SIMILAR TO
+            ILIKE: 5,
+            SIMILAR: 5,
             '<': 6, // comparison operators
             '<=': 6,
             '>': 6,
@@ -869,6 +1024,12 @@ class Deparser {
                 output.push(context.parens(columnNames.join(', ')));
             }
         }
+        if (node.override === 'OVERRIDING_USER_VALUE') {
+            output.push('OVERRIDING USER VALUE');
+        }
+        else if (node.override === 'OVERRIDING_SYSTEM_VALUE') {
+            output.push('OVERRIDING SYSTEM VALUE');
+        }
         if (node.selectStmt) {
             output.push(this.visit(node.selectStmt, context));
         }
@@ -911,7 +1072,14 @@ class Deparser {
                     else {
                         const updateContext = context.spawn('UpdateStmt', { update: true });
                         const targets = targetList.map(target => this.visit(target, updateContext));
-                        output.push(targets.join(', '));
+                        if (context.isPretty()) {
+                            // Put each assignment on its own line for pretty printing
+                            const indentedTargets = targets.map(target => context.indent(target));
+                            output[output.length - 1] += '\n' + indentedTargets.join(',\n');
+                        }
+                        else {
+                            output.push(targets.join(', '));
+                        }
                     }
                 }
                 if (node.onConflictClause.whereClause) {
@@ -923,11 +1091,8 @@ class Deparser {
                 output.push('DO NOTHING');
             }
         }
-        if (node.returningList) {
-            output.push('RETURNING');
-            const returningList = list_utils_1.ListUtils.unwrapList(node.returningList);
-            const returns = returningList.map(ret => this.visit(ret, context));
-            output.push(returns.join(', '));
+        if (node.returningClause) {
+            output.push(this.ReturningClause(node.returningClause, context));
         }
         return output.join(' ');
     }
@@ -941,38 +1106,8 @@ class Deparser {
             output.push(this.RangeVar(node.relation, context));
         }
         output.push('SET');
-        const targetList = list_utils_1.ListUtils.unwrapList(node.targetList);
-        if (targetList && targetList.length) {
-            const firstTarget = targetList[0];
-            const processedTargets = new Set();
-            const assignmentParts = [];
-            for (let i = 0; i < targetList.length; i++) {
-                if (processedTargets.has(i))
-                    continue;
-                const target = targetList[i];
-                const multiAssignRef = target.ResTarget?.val?.MultiAssignRef;
-                if (multiAssignRef) {
-                    const relatedTargets = [];
-                    for (let j = i; j < targetList.length; j++) {
-                        const otherTarget = targetList[j];
-                        const otherMultiAssignRef = otherTarget.ResTarget?.val?.MultiAssignRef;
-                        if (otherMultiAssignRef &&
-                            JSON.stringify(otherMultiAssignRef.source) === JSON.stringify(multiAssignRef.source)) {
-                            relatedTargets.push(otherTarget);
-                            processedTargets.add(j);
-                        }
-                    }
-                    const names = relatedTargets.map(t => t.ResTarget.name);
-                    const multiAssignment = `${context.parens(names.join(', '))} = ${this.visit(multiAssignRef.source, context)}`;
-                    assignmentParts.push(multiAssignment);
-                }
-                else {
-                    // Handle regular single-column assignment
-                    assignmentParts.push(this.visit(target, context.spawn('UpdateStmt', { update: true })));
-                    processedTargets.add(i);
-                }
-            }
-            output.push(assignmentParts.join(','));
+        if (node.targetList && node.targetList.length > 0) {
+            output.push(this.formatUpdateAssignments(node.targetList, context));
         }
         if (node.fromClause) {
             output.push('FROM');
@@ -984,12 +1119,41 @@ class Deparser {
             output.push('WHERE');
             output.push(this.visit(node.whereClause, context));
         }
-        if (node.returningList) {
-            output.push('RETURNING');
-            output.push(this.deparseReturningList(node.returningList, context));
+        if (node.returningClause) {
+            output.push(this.ReturningClause(node.returningClause, context));
         }
         return output.join(' ');
     }
+    formatUpdateAssignments(targets, context) {
+        const targetList = list_utils_1.ListUtils.unwrapList(targets);
+        const processedTargets = new Set();
+        const assignmentParts = [];
+        for (let i = 0; i < targetList.length; i++) {
+            if (processedTargets.has(i))
+                continue;
+            const target = targetList[i];
+            const multiAssignRef = target.ResTarget?.val?.MultiAssignRef;
+            if (multiAssignRef) {
+                const relatedTargets = [];
+                for (let j = i; j < targetList.length; j++) {
+                    const otherTarget = targetList[j];
+                    const otherMultiAssignRef = otherTarget.ResTarget?.val?.MultiAssignRef;
+                    if (otherMultiAssignRef &&
+                        JSON.stringify(otherMultiAssignRef.source) === JSON.stringify(multiAssignRef.source)) {
+                        relatedTargets.push(otherTarget);
+                        processedTargets.add(j);
+                    }
+                }
+                const names = relatedTargets.map(t => quotes_1.QuoteUtils.quoteIdentifier(t.ResTarget.name));
+                assignmentParts.push(`${context.parens(names.join(', '))} = ${this.visit(multiAssignRef.source, context)}`);
+            }
+            else {
+                assignmentParts.push(this.visit(target, context.spawn('UpdateStmt', { update: true })));
+                processedTargets.add(i);
+            }
+        }
+        return assignmentParts.join(', ');
+    }
     DeleteStmt(node, context) {
         try {
             const output = [];
@@ -1037,13 +1201,12 @@ class Deparser {
                     throw new Error(`Error deparsing DeleteStmt: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
-            if (node.returningList) {
-                output.push('RETURNING');
+            if (node.returningClause) {
                 try {
-                    output.push(this.deparseReturningList(node.returningList, context));
+                    output.push(this.ReturningClause(node.returningClause, context));
                 }
                 catch (error) {
-                    console.warn(`Error processing returningList in DeleteStmt: ${error instanceof Error ? error.message : String(error)}`);
+                    console.warn(`Error processing returningClause in DeleteStmt: ${error instanceof Error ? error.message : String(error)}`);
                     throw new Error(`Error deparsing DeleteStmt: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
@@ -1064,9 +1227,6 @@ class Deparser {
                 const cteStrings = ctes.map((cte, index) => {
                     const cteStr = this.visit(cte, context);
                     const prefix = index === 0 ? context.newline() : ',' + context.newline();
-                    if (this.containsMultilineStringLiteral(cteStr)) {
-                        return prefix + cteStr;
-                    }
                     return prefix + context.indent(cteStr);
                 });
                 output.push(cteStrings.join(''));
@@ -1081,12 +1241,12 @@ class Deparser {
     ResTarget(node, context) {
         const output = [];
         if (context.update && node.name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
             // Handle indirection (array indexing, field access, etc.)
             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.quote(item.String.sval || item.String.str)}`;
+                        return `.${quotes_1.QuoteUtils.quoteIdentifierAfterDot(item.String.sval || item.String.str)}`;
                     }
                     return this.visit(item, context);
                 });
@@ -1098,12 +1258,12 @@ class Deparser {
             }
         }
         else if (context.insertColumns && node.name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
             // Handle indirection for INSERT column lists (e.g., q.c1.r)
             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.quote(item.String.sval || item.String.str)}`;
+                        return `.${quotes_1.QuoteUtils.quoteIdentifierAfterDot(item.String.sval || item.String.str)}`;
                     }
                     return this.visit(item, context);
                 });
@@ -1116,11 +1276,53 @@ class Deparser {
             }
             if (node.name) {
                 output.push('AS');
-                output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
+            }
+        }
+        return output.join(' ');
+    }
+    ATAlterConstraint(node, context) {
+        const output = ['ALTER CONSTRAINT'];
+        if (node.conname) {
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.conname));
+        }
+        if (node.alterEnforceability) {
+            output.push(node.is_enforced ? 'ENFORCED' : 'NOT ENFORCED');
+        }
+        if (node.alterDeferrability) {
+            output.push(node.deferrable ? 'DEFERRABLE' : 'NOT DEFERRABLE');
+            if (node.initdeferred) {
+                output.push('INITIALLY DEFERRED');
             }
         }
+        if (node.alterInheritability) {
+            output.push(node.noinherit ? 'NO INHERIT' : 'INHERIT');
+        }
+        return output.join(' ');
+    }
+    deparseKeyAttrs(attrs, withPeriod, context) {
+        const items = list_utils_1.ListUtils.unwrapList(attrs).map(attr => this.visit(attr, context));
+        if (withPeriod && items.length > 0) {
+            items[items.length - 1] = `PERIOD ${items[items.length - 1]}`;
+        }
+        return items.join(', ');
+    }
+    ReturningClause(node, context) {
+        const output = ['RETURNING'];
+        if (node.options && node.options.length > 0) {
+            const options = list_utils_1.ListUtils.unwrapList(node.options)
+                .map(option => this.visit(option, context));
+            output.push(`WITH (${options.join(', ')})`);
+        }
+        if (node.exprs && node.exprs.length > 0) {
+            output.push(this.deparseReturningList(node.exprs, context));
+        }
         return output.join(' ');
     }
+    ReturningOption(node, context) {
+        const keyword = node.option === 'RETURNING_OPTION_NEW' ? 'NEW' : 'OLD';
+        return `${keyword} AS ${quotes_1.QuoteUtils.quoteIdentifier(node.value)}`;
+    }
     deparseReturningList(list, context) {
         return list_utils_1.ListUtils.unwrapList(list)
             .filter(item => item != null && this.getNodeType(item) !== 'undefined')
@@ -1130,7 +1332,7 @@ class Deparser {
                 if (this.getNodeType(item) === 'ResTarget') {
                     const resTarget = this.getNodeData(item);
                     const val = resTarget.val ? this.visit(resTarget.val, context) : '';
-                    const alias = resTarget.name ? ` AS ${quote_utils_1.QuoteUtils.quote(resTarget.name)}` : '';
+                    const alias = resTarget.name ? ` AS ${quotes_1.QuoteUtils.quoteIdentifier(resTarget.name)}` : '';
                     return val + alias;
                 }
                 else {
@@ -1185,7 +1387,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 = quotes_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);
@@ -1194,8 +1397,15 @@ class Deparser {
         }
         // Handle EXTRACT function with SQL syntax
         if (node.funcformat === 'COERCE_SQL_SYNTAX' && name === 'pg_catalog.extract' && args.length >= 2) {
-            const field = this.visit(args[0], context);
+            let field = this.visit(args[0], context);
             const source = this.visit(args[1], context);
+            // EXTRACT requires an unquoted uppercase keyword (EPOCH, YEAR, etc.)
+            // but A_Const sval deparsing wraps it in single quotes — strip and uppercase
+            // only when it is spelled the way the bare-keyword form parses back
+            if (/^'(?:year|month|day|hour|minute|second)'$/.test(field)
+                || (/^'[a-z_][a-z0-9_]*'$/.test(field) && (0, quotes_1.keywordKindOf)(field.slice(1, -1)) === 'NO_KEYWORD')) {
+                field = field.slice(1, -1).toUpperCase();
+            }
             return `EXTRACT(${field} FROM ${source})`;
         }
         // Handle TRIM function with SQL syntax (TRIM TRAILING/LEADING/BOTH)
@@ -1355,43 +1565,41 @@ class Deparser {
             result += ` FILTER (WHERE ${this.visit(node.agg_filter, context)})`;
         }
         if (node.over) {
-            // Handle named window references first
-            if (node.over.name) {
-                result += ` OVER ${node.over.name}`;
-            }
-            else {
-                const windowParts = [];
-                if (node.over.partitionClause) {
-                    const partitions = list_utils_1.ListUtils.unwrapList(node.over.partitionClause);
-                    const partitionStrs = partitions.map(p => this.visit(p, context));
-                    windowParts.push(`PARTITION BY ${partitionStrs.join(', ')}`);
-                }
-                if (node.over.orderClause) {
-                    const orders = list_utils_1.ListUtils.unwrapList(node.over.orderClause);
-                    const orderStrs = orders.map(o => this.visit(o, context));
-                    windowParts.push(`ORDER BY ${orderStrs.join(', ')}`);
-                }
-                // Handle window frame specifications using the dedicated formatWindowFrame method
-                const frameClause = this.formatWindowFrame(node.over, context.spawn('FuncCall'));
-                if (frameClause) {
-                    windowParts.push(frameClause);
-                }
-                if (windowParts.length > 0) {
-                    if (context.isPretty() && windowParts.length > 1) {
-                        const formattedParts = windowParts.map(part => context.indent(part));
-                        result += ` OVER (${context.newline()}${formattedParts.join(context.newline())}${context.newline()})`;
-                    }
-                    else {
-                        result += ` OVER (${windowParts.join(' ')})`;
-                    }
-                }
-                else {
-                    result += ` OVER ()`;
-                }
-            }
+            result += this.formatOverClause(node.over, context);
         }
         return result;
     }
+    formatOverClause(over, context) {
+        if (over.name) {
+            return ` OVER ${over.name}`;
+        }
+        const windowParts = [];
+        if (over.refname) {
+            windowParts.push(over.refname);
+        }
+        if (over.partitionClause) {
+            const partitions = list_utils_1.ListUtils.unwrapList(over.partitionClause);
+            const partitionStrs = partitions.map(p => this.visit(p, context));
+            windowParts.push(`PARTITION BY ${partitionStrs.join(', ')}`);
+        }
+        if (over.orderClause) {
+            const orders = list_utils_1.ListUtils.unwrapList(over.orderClause);
+            const orderStrs = orders.map(o => this.visit(o, context));
+            windowParts.push(`ORDER BY ${orderStrs.join(', ')}`);
+        }
+        const frameClause = this.formatWindowFrame(over, context.spawn('FuncCall'));
+        if (frameClause) {
+            windowParts.push(frameClause);
+        }
+        if (windowParts.length === 0) {
+            return ' OVER ()';
+        }
+        if (context.isPretty() && windowParts.length > 1) {
+            const formattedParts = windowParts.map(part => context.indent(part));
+            return ` OVER (${context.newline()}${formattedParts.join(context.newline())}${context.newline()})`;
+        }
+        return ` OVER (${windowParts.join(' ')})`;
+    }
     FuncExpr(node, context) {
         const funcName = `func_${node.funcid}`;
         const args = node.args ? list_utils_1.ListUtils.unwrapList(node.args).map(arg => this.visit(arg, context)).join(', ') : '';
@@ -1402,61 +1610,61 @@ class Deparser {
         if (nodeAny.ival !== undefined) {
             if (typeof nodeAny.ival === 'object' && nodeAny.ival !== null) {
                 if (nodeAny.ival.ival !== undefined) {
-                    return nodeAny.ival.ival.toString();
+                    return formatInteger(nodeAny.ival.ival);
                 }
                 else if (Object.keys(nodeAny.ival).length === 0) {
                     return '0';
                 }
                 else {
-                    return nodeAny.ival.toString();
+                    return formatInteger(nodeAny.ival);
                 }
             }
             else if (nodeAny.ival === null) {
                 return 'NULL';
             }
             else {
-                return nodeAny.ival.toString();
+                return formatInteger(nodeAny.ival);
             }
         }
         else if (nodeAny.fval !== undefined) {
             if (typeof nodeAny.fval === 'object' && nodeAny.fval !== null) {
                 if (nodeAny.fval.fval !== undefined) {
-                    return nodeAny.fval.fval.toString();
+                    return formatNumeric(nodeAny.fval.fval);
                 }
                 else if (Object.keys(nodeAny.fval).length === 0) {
                     return '0.0';
                 }
                 else {
-                    return nodeAny.fval.toString();
+                    return formatNumeric(nodeAny.fval);
                 }
             }
             else if (nodeAny.fval === null) {
                 return 'NULL';
             }
             else {
-                return nodeAny.fval.toString();
+                return formatNumeric(nodeAny.fval);
             }
         }
         else if (nodeAny.sval !== undefined) {
             if (typeof nodeAny.sval === 'object' && nodeAny.sval !== null) {
                 if (nodeAny.sval.sval !== undefined) {
-                    return quote_utils_1.QuoteUtils.formatEString(nodeAny.sval.sval);
+                    return quotes_1.QuoteUtils.formatEString(nodeAny.sval.sval);
                 }
                 else if (nodeAny.sval.String && nodeAny.sval.String.sval !== undefined) {
-                    return quote_utils_1.QuoteUtils.formatEString(nodeAny.sval.String.sval);
+                    return quotes_1.QuoteUtils.formatEString(nodeAny.sval.String.sval);
                 }
                 else if (Object.keys(nodeAny.sval).length === 0) {
                     return "''";
                 }
                 else {
-                    return quote_utils_1.QuoteUtils.formatEString(nodeAny.sval.toString());
+                    return quotes_1.QuoteUtils.formatEString(nodeAny.sval.toString());
                 }
             }
             else if (nodeAny.sval === null) {
                 return 'NULL';
             }
             else {
-                return quote_utils_1.QuoteUtils.formatEString(nodeAny.sval);
+                return quotes_1.QuoteUtils.formatEString(nodeAny.sval);
             }
         }
         else if (nodeAny.boolval !== undefined) {
@@ -1481,15 +1689,7 @@ class Deparser {
         else if (nodeAny.bsval !== undefined) {
             if (typeof nodeAny.bsval === 'object' && nodeAny.bsval !== null) {
                 if (nodeAny.bsval.bsval !== undefined) {
-                    const bsval = nodeAny.bsval.bsval;
-                    // Check if this is a hexadecimal bit string (starts with x and contains only hex digits)
-                    if (bsval.startsWith('x') && /^x[0-9A-Fa-f]+$/.test(bsval)) {
-                        return `x'${bsval.substring(1)}'`;
-                    }
-                    if (bsval.startsWith('b')) {
-                        return `b'${bsval.substring(1)}'`;
-                    }
-                    return `b'${bsval}'`;
+                    return formatBitString(nodeAny.bsval.bsval);
                 }
                 else if (Object.keys(nodeAny.bsval).length === 0) {
                     return "''";
@@ -1502,32 +1702,24 @@ class Deparser {
                 return 'NULL';
             }
             else {
-                const bsval = nodeAny.bsval;
-                // Check if this is a hexadecimal bit string (starts with x and contains only hex digits)
-                if (bsval.startsWith('x') && /^x[0-9A-Fa-f]+$/.test(bsval)) {
-                    return `x'${bsval.substring(1)}'`;
-                }
-                if (bsval.startsWith('b')) {
-                    return `b'${bsval.substring(1)}'`;
-                }
-                return `b'${bsval}'`;
+                return formatBitString(nodeAny.bsval);
             }
         }
         if (nodeAny.val) {
             if (nodeAny.val.Integer?.ival !== undefined) {
-                return nodeAny.val.Integer.ival.toString();
+                return formatInteger(nodeAny.val.Integer.ival);
             }
             else if (nodeAny.val.Float?.fval !== undefined) {
-                return nodeAny.val.Float.fval.toString();
+                return formatNumeric(nodeAny.val.Float.fval);
             }
             else if (nodeAny.val.String?.sval !== undefined) {
-                return quote_utils_1.QuoteUtils.escape(nodeAny.val.String.sval);
+                return quotes_1.QuoteUtils.escape(nodeAny.val.String.sval);
             }
             else if (nodeAny.val.Boolean?.boolval !== undefined) {
                 return nodeAny.val.Boolean.boolval ? 'true' : 'false';
             }
             else if (nodeAny.val.BitString?.bsval !== undefined) {
-                return nodeAny.val.BitString.bsval;
+                return formatBitString(nodeAny.val.BitString.bsval);
             }
         }
         if (nodeAny.isnull === true) {
@@ -1539,21 +1731,21 @@ class Deparser {
             }
             if (nodeAny.Integer !== undefined) {
                 if (typeof nodeAny.Integer === 'object' && nodeAny.Integer.ival !== undefined) {
-                    return nodeAny.Integer.ival.toString();
+                    return formatInteger(nodeAny.Integer.ival);
                 }
-                return nodeAny.Integer.toString();
+                return formatInteger(nodeAny.Integer);
             }
             if (nodeAny.Float !== undefined) {
                 if (typeof nodeAny.Float === 'object' && nodeAny.Float.fval !== undefined) {
-                    return nodeAny.Float.fval.toString();
+                    return formatNumeric(nodeAny.Float.fval);
                 }
-                return nodeAny.Float.toString();
+                return formatNumeric(nodeAny.Float);
             }
             if (nodeAny.String !== undefined) {
                 if (typeof nodeAny.String === 'object' && nodeAny.String.sval !== undefined) {
-                    return quote_utils_1.QuoteUtils.escape(nodeAny.String.sval);
+                    return quotes_1.QuoteUtils.escape(nodeAny.String.sval);
                 }
-                return quote_utils_1.QuoteUtils.escape(nodeAny.String);
+                return quotes_1.QuoteUtils.escape(nodeAny.String);
             }
             if (Object.keys(nodeAny).length === 0) {
                 return 'NULL';
@@ -1567,7 +1759,7 @@ class Deparser {
         const fields = list_utils_1.ListUtils.unwrapList(node.fields);
         return fields.map(field => {
             if (field.String) {
-                return quote_utils_1.QuoteUtils.quote(field.String.sval || field.String.str);
+                return quotes_1.QuoteUtils.quoteIdentifier(field.String.sval || field.String.str);
             }
             else if (field.A_Star) {
                 return '*';
@@ -1644,8 +1836,7 @@ class Deparser {
                 }
                 return output.join(' ');
             }
-            const quotedTypeName = quote_utils_1.QuoteUtils.quote(typeName);
-            let result = mods(quotedTypeName, args);
+            let result = mods(quotes_1.QuoteUtils.quoteIdentifierTypeName(typeName), args);
             if (node.arrayBounds && node.arrayBounds.length > 0) {
                 result += formatArrayBounds(node.arrayBounds);
             }
@@ -1741,8 +1932,9 @@ class Deparser {
                 return output.join(' ');
             }
         }
-        const quotedNames = names.map((name) => quote_utils_1.QuoteUtils.quote(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(quotes_1.QuoteUtils.quoteTypeDottedName(names), args);
         if (node.arrayBounds && node.arrayBounds.length > 0) {
             result += formatArrayBounds(node.arrayBounds);
         }
@@ -1780,17 +1972,17 @@ class Deparser {
         }
         let tableName = '';
         if (node.catalogname) {
-            tableName = quote_utils_1.QuoteUtils.quote(node.catalogname);
+            tableName = quotes_1.QuoteUtils.quoteIdentifier(node.catalogname);
             if (node.schemaname) {
-                tableName += '.' + quote_utils_1.QuoteUtils.quote(node.schemaname);
+                tableName += '.' + quotes_1.QuoteUtils.quoteIdentifierAfterDot(node.schemaname);
             }
-            tableName += '.' + quote_utils_1.QuoteUtils.quote(node.relname);
+            tableName += '.' + quotes_1.QuoteUtils.quoteIdentifierAfterDot(node.relname);
         }
         else if (node.schemaname) {
-            tableName = quote_utils_1.QuoteUtils.quote(node.schemaname) + '.' + quote_utils_1.QuoteUtils.quote(node.relname);
+            tableName = quotes_1.QuoteUtils.quoteQualifiedIdentifier(node.schemaname, node.relname);
         }
         else {
-            tableName = quote_utils_1.QuoteUtils.quote(node.relname);
+            tableName = quotes_1.QuoteUtils.quoteIdentifier(node.relname);
         }
         output.push(tableName);
         if (node.alias) {
@@ -1944,7 +2136,7 @@ class Deparser {
                 if (size != null) {
                     return 'char';
                 }
-                return 'pg_catalog.bpchar';
+                return 'bpchar';
             case 'varchar':
                 return 'varchar';
             case 'numeric':
@@ -1958,7 +2150,7 @@ class Deparser {
             case 'int8':
                 return 'bigint';
             case 'real':
-                return 'pg_catalog.float4';
+                return 'float4';
             case 'time':
                 return 'time';
             case 'timestamp':
@@ -1968,7 +2160,7 @@ class Deparser {
             case 'bit':
                 return 'bit';
             default:
-                return `pg_catalog.${typeName}`;
+                return typeName;
         }
     }
     isPgCatalogType(typeName) {
@@ -2009,14 +2201,16 @@ class Deparser {
     A_Indirection(node, context) {
         let argStr = this.visit(node.arg, context);
         const argType = this.getNodeType(node.arg);
-        if (argType === 'TypeCast' || argType === 'SubLink' || argType === 'A_Expr' || argType === 'FuncCall' || argType === 'A_Indirection' || argType === 'ColumnRef' || argType === 'RowExpr') {
+        // Grammar: only a parameter takes indirection bare; every other target is
+        // `'(' a_expr ')' opt_indirection` (a plain column subscript is the same node).
+        if (argType !== 'ParamRef') {
             argStr = `(${argStr})`;
         }
         const output = [argStr];
         const indirection = list_utils_1.ListUtils.unwrapList(node.indirection);
         for (const subnode of indirection) {
             if (subnode.String || subnode.A_Star) {
-                const value = subnode.A_Star ? '*' : quote_utils_1.QuoteUtils.quote(subnode.String.sval || subnode.String.str);
+                const value = subnode.A_Star ? '*' : quotes_1.QuoteUtils.quoteIdentifier(subnode.String.sval || subnode.String.str);
                 output.push(`.${value}`);
             }
             else {
@@ -2037,21 +2231,11 @@ class Deparser {
         if (context.isPretty() && args.length > 0) {
             for (const arg of args) {
                 const whenClause = this.visit(arg, context);
-                if (this.containsMultilineStringLiteral(whenClause)) {
-                    output.push(context.newline() + whenClause);
-                }
-                else {
-                    output.push(context.newline() + context.indent(whenClause));
-                }
+                output.push(context.newline() + context.indent(whenClause));
             }
             if (node.defresult) {
                 const elseResult = this.visit(node.defresult, context);
-                if (this.containsMultilineStringLiteral(elseResult)) {
-                    output.push(context.newline() + 'ELSE ' + elseResult);
-                }
-                else {
-                    output.push(context.newline() + context.indent('ELSE ' + elseResult));
-                }
+                output.push(context.newline() + context.indent('ELSE ' + elseResult));
             }
             output.push(context.newline() + 'END');
             return output.join(' ');
@@ -2092,10 +2276,13 @@ class Deparser {
             const isFunctionCall = argType === 'FuncCall';
             if (isSimpleArgument || isFunctionCall) {
                 // For simple arguments, avoid :: syntax if they have complex structure
-                if (isSimpleArgument && (arg.includes('(') || arg.startsWith('-'))) {
-                }
-                else {
+                const shouldUseCastSyntax = isSimpleArgument && (arg.includes('(') || arg.startsWith('-'));
+                if (!shouldUseCastSyntax) {
                     const cleanTypeName = typeName.replace('pg_catalog.', '');
+                    // Wrap FuncCall arguments in parentheses to prevent operator precedence issues
+                    if (isFunctionCall) {
+                        return `${context.parens(arg)}::${cleanTypeName}`;
+                    }
                     return `${arg}::${cleanTypeName}`;
                 }
             }
@@ -2158,51 +2345,27 @@ class Deparser {
         }
         return output.join(' ');
     }
-    static RESERVED_WORDS = new Set([
-        'all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric', 'both',
-        'case', 'cast', 'check', 'collate', 'column', 'constraint', 'create', 'current_catalog',
-        'current_date', 'current_role', 'current_time', 'current_timestamp', 'current_user',
-        'default', 'deferrable', 'desc', 'distinct', 'do', 'else', 'end', 'except', 'false',
-        'fetch', 'for', 'foreign', 'from', 'grant', 'group', 'having', 'in', 'initially',
-        'intersect', 'into', 'lateral', 'leading', 'limit', 'localtime', 'localtimestamp',
-        'not', 'null', 'offset', 'on', 'only', 'or', 'order', 'placing', 'primary',
-        'references', 'returning', 'select', 'session_user', 'some', 'symmetric', 'table',
-        'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using', 'variadic',
-        'when', 'where', 'window', 'with'
-    ]);
-    static needsQuotes(value) {
-        if (!value)
-            return false;
-        const needsQuotesRegex = /[a-z]+[\W\w]*[A-Z]+|[A-Z]+[\W\w]*[a-z]+|\W/;
-        const isAllUppercase = /^[A-Z]+$/.test(value);
-        return needsQuotesRegex.test(value) ||
-            Deparser.RESERVED_WORDS.has(value.toLowerCase()) ||
-            isAllUppercase;
-    }
     quoteIfNeeded(value) {
-        if (Deparser.needsQuotes(value)) {
-            return `"${value}"`;
-        }
-        return value;
+        return quotes_1.QuoteUtils.quoteIdentifier(value);
     }
     preserveOperatorDefElemCase(defName) {
         const caseMap = {
-            'leftarg': 'Leftarg',
-            'rightarg': 'Rightarg',
-            'procedure': 'Procedure',
-            'function': 'Function',
-            'commutator': 'Commutator',
-            'negator': 'Negator',
-            'restrict': 'Restrict',
-            'join': 'Join',
-            'hashes': 'Hashes',
-            'merges': 'Merges'
+            leftarg: 'Leftarg',
+            rightarg: 'Rightarg',
+            procedure: 'Procedure',
+            function: 'Function',
+            commutator: 'Commutator',
+            negator: 'Negator',
+            restrict: 'Restrict',
+            join: 'Join',
+            hashes: 'Hashes',
+            merges: 'Merges'
         };
         return caseMap[defName.toLowerCase()] || defName;
     }
     String(node, context) {
         if (context.isStringLiteral || context.isEnumValue) {
-            return quote_utils_1.QuoteUtils.formatEString(node.sval || '');
+            return quotes_1.QuoteUtils.formatEString(node.sval || '');
         }
         const value = node.sval || '';
         if (context.parentNodeTypes.includes('DefElem') ||
@@ -2216,27 +2379,19 @@ class Deparser {
                 return value; // Don't quote pure operator symbols like "=" or "-"
             }
         }
-        return Deparser.needsQuotes(value) ? `"${value}"` : value;
+        return quotes_1.QuoteUtils.quoteIdentifier(value);
     }
     Integer(node, context) {
-        return node.ival?.toString() || '0';
+        return node.ival === undefined || node.ival === null ? '0' : formatInteger(node.ival);
     }
     Float(node, context) {
-        return node.fval || '0.0';
+        return node.fval ? formatNumeric(node.fval) : '0.0';
     }
     Boolean(node, context) {
         return node.boolval ? 'true' : 'false';
     }
     BitString(node, context) {
-        // Check if this is a hexadecimal bit string (starts with x)
-        if (node.bsval.startsWith('x')) {
-            return `x'${node.bsval.substring(1)}'`;
-        }
-        if (node.bsval.startsWith('b')) {
-            return `b'${node.bsval.substring(1)}'`;
-        }
-        // Fallback for raw values without prefix
-        return `b'${node.bsval}'`;
+        return formatBitString(node.bsval);
     }
     Null(node, context) {
         return 'NULL';
@@ -2275,7 +2430,7 @@ class Deparser {
                 output.push(context.parens(elementStrs.join(', ')));
             }
         }
-        else if (node.tableElts) {
+        else if (node.tableElts && !node.partbound) {
             const elements = list_utils_1.ListUtils.unwrapList(node.tableElts);
             const elementStrs = elements.map(el => {
                 return this.deparse(el, context.spawn('CreateStmt'));
@@ -2303,7 +2458,16 @@ class Deparser {
             const inherits = list_utils_1.ListUtils.unwrapList(node.inhRelations);
             const inheritStrs = inherits.map(rel => this.visit(rel, context));
             output.push(inheritStrs[0]);
-            if (node.partbound.strategy === 'l' && node.partbound.listdatums) {
+            if (node.tableElts) {
+                const elementStrs = list_utils_1.ListUtils.unwrapList(node.tableElts).map(el => {
+                    return this.deparse(el, context.spawn('CreateStmt'));
+                });
+                output.push(context.parens(elementStrs.join(', ')));
+            }
+            if (node.partbound.is_default) {
+                output.push('DEFAULT');
+            }
+            else if (node.partbound.strategy === 'l' && node.partbound.listdatums) {
                 output.push('FOR VALUES IN');
                 const listValues = list_utils_1.ListUtils.unwrapList(node.partbound.listdatums)
                     .map(datum => this.visit(datum, context))
@@ -2326,13 +2490,9 @@ class Deparser {
                     output.push(`(${upperValues})`);
                 }
             }
-            else if (node.partbound.strategy === 'h' && node.partbound.modulus !== undefined) {
+            else if (node.partbound.strategy === 'h') {
                 output.push('FOR VALUES WITH');
-                const remainder = node.partbound.remainder !== undefined ? node.partbound.remainder : 0;
-                output.push(`(MODULUS ${node.partbound.modulus}, REMAINDER ${remainder})`);
-            }
-            else if (node.partbound.is_default) {
-                output.push('DEFAULT');
+                output.push(`(MODULUS ${node.partbound.modulus ?? 0}, REMAINDER ${node.partbound.remainder ?? 0})`);
             }
         }
         else if (node.inhRelations) {
@@ -2393,11 +2553,17 @@ class Deparser {
     ColumnDef(node, context) {
         const output = [];
         if (node.colname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.colname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.colname));
         }
         if (node.typeName) {
             output.push(this.TypeName(node.typeName, context));
         }
+        if (node.storage_name) {
+            output.push('STORAGE', node.storage_name.toUpperCase());
+        }
+        if (node.compression) {
+            output.push('COMPRESSION', quotes_1.QuoteUtils.quoteIdentifier(node.compression));
+        }
         if (node.fdwoptions && node.fdwoptions.length > 0) {
             output.push('OPTIONS');
             const columnContext = context.spawn('ColumnDef');
@@ -2432,9 +2598,9 @@ class Deparser {
     Constraint(node, context) {
         const output = [];
         // Handle constraint name if present
-        if (node.conname && (node.contype === 'CONSTR_CHECK' || node.contype === 'CONSTR_UNIQUE' || node.contype === 'CONSTR_PRIMARY' || node.contype === 'CONSTR_FOREIGN')) {
+        if (node.conname && (node.contype === 'CONSTR_CHECK' || node.contype === 'CONSTR_UNIQUE' || node.contype === 'CONSTR_PRIMARY' || node.contype === 'CONSTR_FOREIGN' || node.contype === 'CONSTR_NOTNULL' || node.contype === 'CONSTR_EXCLUSION')) {
             output.push('CONSTRAINT');
-            output.push(quote_utils_1.QuoteUtils.quote(node.conname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.conname));
         }
         switch (node.contype) {
             case 'CONSTR_NULL':
@@ -2442,11 +2608,24 @@ class Deparser {
                 break;
             case 'CONSTR_NOTNULL':
                 output.push('NOT NULL');
+                if (node.keys && node.keys.length > 0 && !context.isColumnConstraint) {
+                    const keyList = list_utils_1.ListUtils.unwrapList(node.keys)
+                        .map(key => this.visit(key, context))
+                        .join(', ');
+                    output.push(keyList);
+                }
+                if (node.is_no_inherit) {
+                    output.push('NO INHERIT');
+                }
+                if (node.skip_validation) {
+                    output.push('NOT VALID');
+                }
                 break;
             case 'CONSTR_DEFAULT':
                 output.push('DEFAULT');
                 if (node.raw_expr) {
-                    output.push(this.visit(node.raw_expr, context));
+                    const defaultExpr = this.visit(node.raw_expr, context);
+                    output.push(this.needsBExprParens(node.raw_expr) ? `(${defaultExpr})` : defaultExpr);
                 }
                 break;
             case 'CONSTR_CHECK':
@@ -2470,8 +2649,13 @@ class Deparser {
                         output.push(context.parens(this.visit(node.raw_expr, context)));
                     }
                 }
-                // Handle NOT VALID for check constraints
-                if (node.skip_validation) {
+                // PG18: constraints are enforced unless explicitly NOT ENFORCED
+                // (libpg-query omits false booleans, so undefined means not enforced)
+                if (node.is_enforced !== true && !context.isDomainConstraint) {
+                    output.push('NOT ENFORCED');
+                }
+                else if (node.skip_validation) {
+                    // NOT ENFORCED implies NOT VALID, so only emit NOT VALID when enforced
                     output.push('NOT VALID');
                 }
                 // Handle NO INHERIT for check constraints - only for table constraints, not domain constraints
@@ -2491,7 +2675,7 @@ class Deparser {
                 if (node.raw_expr) {
                     output.push(context.parens(this.visit(node.raw_expr, context)));
                 }
-                output.push('STORED');
+                output.push(node.generated_kind === 'v' ? 'VIRTUAL' : 'STORED');
                 break;
             case 'CONSTR_IDENTITY':
                 output.push('GENERATED');
@@ -2567,10 +2751,12 @@ class Deparser {
             case 'CONSTR_PRIMARY':
                 output.push('PRIMARY KEY');
                 if (node.keys && node.keys.length > 0) {
-                    const keyList = list_utils_1.ListUtils.unwrapList(node.keys)
-                        .map(key => this.visit(key, context))
-                        .join(', ');
-                    output.push(`(${keyList})`);
+                    const keyItems = list_utils_1.ListUtils.unwrapList(node.keys)
+                        .map(key => this.visit(key, context));
+                    if (node.without_overlaps) {
+                        keyItems[keyItems.length - 1] += ' WITHOUT OVERLAPS';
+                    }
+                    output.push(`(${keyItems.join(', ')})`);
                 }
                 if (node.indexname) {
                     output.push('USING INDEX');
@@ -2588,10 +2774,12 @@ class Deparser {
                     output.push('NULLS NOT DISTINCT');
                 }
                 if (node.keys && node.keys.length > 0) {
-                    const keyList = list_utils_1.ListUtils.unwrapList(node.keys)
-                        .map(key => this.visit(key, context))
-                        .join(', ');
-                    output.push(`(${keyList})`);
+                    const keyItems = list_utils_1.ListUtils.unwrapList(node.keys)
+                        .map(key => this.visit(key, context));
+                    if (node.without_overlaps) {
+                        keyItems[keyItems.length - 1] += ' WITHOUT OVERLAPS';
+                    }
+                    output.push(`(${keyItems.join(', ')})`);
                 }
                 if (node.indexname) {
                     output.push('USING INDEX');
@@ -2604,20 +2792,14 @@ class Deparser {
                     if (context.isPretty()) {
                         output.push('\n' + context.indent('FOREIGN KEY'));
                         if (node.fk_attrs && node.fk_attrs.length > 0) {
-                            const fkAttrs = list_utils_1.ListUtils.unwrapList(node.fk_attrs)
-                                .map(attr => this.visit(attr, context))
-                                .join(', ');
-                            output.push(`(${fkAttrs})`);
+                            output.push(`(${this.deparseKeyAttrs(node.fk_attrs, node.fk_with_period, context)})`);
                         }
                         output.push('\n' + context.indent('REFERENCES'));
                     }
                     else {
                         output.push('FOREIGN KEY');
                         if (node.fk_attrs && node.fk_attrs.length > 0) {
-                            const fkAttrs = list_utils_1.ListUtils.unwrapList(node.fk_attrs)
-                                .map(attr => this.visit(attr, context))
-                                .join(', ');
-                            output.push(`(${fkAttrs})`);
+                            output.push(`(${this.deparseKeyAttrs(node.fk_attrs, node.fk_with_period, context)})`);
                         }
                         output.push('REFERENCES');
                     }
@@ -2640,9 +2822,7 @@ class Deparser {
                     }
                 }
                 if (node.pk_attrs && node.pk_attrs.length > 0) {
-                    const pkAttrs = list_utils_1.ListUtils.unwrapList(node.pk_attrs)
-                        .map(attr => this.visit(attr, context))
-                        .join(', ');
+                    const pkAttrs = this.deparseKeyAttrs(node.pk_attrs, node.pk_with_period, context);
                     if (context.isPretty() && !context.isColumnConstraint) {
                         const lastIndex = output.length - 1;
                         if (lastIndex >= 0) {
@@ -2713,6 +2893,15 @@ class Deparser {
                             deleteClause += 'SET DEFAULT';
                             break;
                     }
+                    if ((node.fk_del_action === 'n' || node.fk_del_action === 'd') && node.fk_del_set_cols && node.fk_del_set_cols.length > 0) {
+                        const setColumns = list_utils_1.ListUtils.unwrapList(node.fk_del_set_cols)
+                            .map(column => {
+                            const stringNode = column.String;
+                            return quotes_1.QuoteUtils.quoteIdentifier(stringNode.sval || stringNode.str || '');
+                        })
+                            .join(', ');
+                        deleteClause += ` (${setColumns})`;
+                    }
                     if (context.isPretty()) {
                         output.push('\n' + context.indent(deleteClause));
                     }
@@ -2721,8 +2910,18 @@ class Deparser {
                         output.push(deleteClause.replace('ON DELETE ', ''));
                     }
                 }
-                // Handle NOT VALID for foreign key constraints - only for table constraints, not domain constraints
-                if (node.skip_validation && !context.isDomainConstraint) {
+                // PG18: constraints are enforced unless explicitly NOT ENFORCED
+                // (libpg-query omits false booleans, so undefined means not enforced)
+                if (node.is_enforced !== true && !context.isDomainConstraint) {
+                    if (context.isPretty() && !context.isColumnConstraint) {
+                        output.push('\n' + context.indent('NOT ENFORCED'));
+                    }
+                    else {
+                        output.push('NOT ENFORCED');
+                    }
+                }
+                else if (node.skip_validation && !context.isDomainConstraint) {
+                    // NOT ENFORCED implies NOT VALID, so only emit NOT VALID when enforced
                     if (context.isPretty() && !context.isColumnConstraint) {
                         output.push('\n' + context.indent('NOT VALID'));
                     }
@@ -2743,6 +2942,12 @@ class Deparser {
             case 'CONSTR_ATTR_IMMEDIATE':
                 output.push('INITIALLY IMMEDIATE');
                 break;
+            case 'CONSTR_ATTR_ENFORCED':
+                output.push('ENFORCED');
+                break;
+            case 'CONSTR_ATTR_NOT_ENFORCED':
+                output.push('NOT ENFORCED');
+                break;
             case 'CONSTR_EXCLUSION':
                 output.push('EXCLUDE');
                 if (node.access_method) {
@@ -2777,10 +2982,14 @@ class Deparser {
                     });
                     output.push(`(${exclusionElements.join(', ')})`);
                 }
+                if (node.where_clause) {
+                    output.push('WHERE');
+                    output.push(context.parens(this.visit(node.where_clause, context)));
+                }
                 break;
         }
         // Handle deferrable constraints for all constraint types that support it
-        if (node.contype === 'CONSTR_PRIMARY' || node.contype === 'CONSTR_UNIQUE' || node.contype === 'CONSTR_FOREIGN') {
+        if (node.contype === 'CONSTR_PRIMARY' || node.contype === 'CONSTR_UNIQUE' || node.contype === 'CONSTR_FOREIGN' || node.contype === 'CONSTR_EXCLUSION') {
             if (node.deferrable) {
                 if (context.isPretty() && node.contype === 'CONSTR_FOREIGN') {
                     output.push('\n' + context.indent('DEFERRABLE'));
@@ -2809,6 +3018,9 @@ class Deparser {
                     output.push('NOT DEFERRABLE');
                 }
             }
+            else if (node.initdeferred) {
+                output.push('INITIALLY DEFERRED');
+            }
         }
         if (context.isPretty() && node.contype === 'CONSTR_FOREIGN') {
             let result = '';
@@ -2874,6 +3086,9 @@ class Deparser {
             output.push(node.name);
         }
         const windowParts = [];
+        if (node.refname) {
+            windowParts.push(node.refname);
+        }
         if (node.partitionClause) {
             const partitions = list_utils_1.ListUtils.unwrapList(node.partitionClause);
             const partitionStrs = partitions.map(p => this.visit(p, context));
@@ -2884,12 +3099,9 @@ class Deparser {
             const orderStrs = orders.map(o => this.visit(o, context));
             windowParts.push(`ORDER BY ${orderStrs.join(', ')}`);
         }
-        // Only add frame clause if frameOptions indicates non-default framing
-        if (node.frameOptions && node.frameOptions !== 1058) {
-            const frameClause = this.formatWindowFrame(node, context.spawn('WindowDef'));
-            if (frameClause) {
-                windowParts.push(frameClause);
-            }
+        const frameClause = this.formatWindowFrame(node, context.spawn('WindowDef'));
+        if (frameClause) {
+            windowParts.push(frameClause);
         }
         if (windowParts.length > 0) {
             if (node.name) {
@@ -2906,103 +3118,97 @@ class Deparser {
         }
         return output.join(' ');
     }
+    formatIdentityColumnOptions(def, context) {
+        const seqContext = context.spawn('AlterSeqStmt');
+        return list_utils_1.ListUtils.unwrapList(def).map(item => {
+            const el = item.DefElem;
+            if (!el)
+                return this.visit(item, context);
+            if (el.defname === 'generated') {
+                const ival = el.arg?.Integer?.ival ?? 0;
+                return ival === 97 ? 'SET GENERATED ALWAYS' : 'SET GENERATED BY DEFAULT';
+            }
+            if (el.defname === 'restart') {
+                return el.arg ? `RESTART WITH ${this.visit(el.arg, context)}` : 'RESTART';
+            }
+            return `SET ${this.visit(item, seqContext)}`;
+        }).join(' ');
+    }
+    // b_expr (used by DEFAULT) excludes IN/LIKE/BETWEEN and boolean operators.
+    needsBExprParens(node) {
+        const nodeType = this.getNodeType(node);
+        if (nodeType === 'BoolExpr')
+            return true;
+        if (nodeType === 'A_Expr') {
+            const kind = this.getNodeData(node).kind;
+            return kind !== 'AEXPR_OP' && kind !== 'AEXPR_DISTINCT' && kind !== 'AEXPR_NOT_DISTINCT';
+        }
+        return false;
+    }
     formatWindowFrame(node, context) {
-        if (!node.frameOptions)
+        if (!node.frameOptions || !(node.frameOptions & FRAMEOPTION_NONDEFAULT))
             return null;
         const frameOptions = node.frameOptions;
         const frameParts = [];
-        if (frameOptions & 0x01) { // FRAMEOPTION_NONDEFAULT
-            if (frameOptions & 0x02) { // FRAMEOPTION_RANGE
-                frameParts.push('RANGE');
-            }
-            else if (frameOptions & 0x04) { // FRAMEOPTION_ROWS
-                frameParts.push('ROWS');
-            }
-            else if (frameOptions & 0x08) { // FRAMEOPTION_GROUPS
-                frameParts.push('GROUPS');
-            }
+        if (frameOptions & FRAMEOPTION_RANGE) {
+            frameParts.push('RANGE');
+        }
+        else if (frameOptions & FRAMEOPTION_ROWS) {
+            frameParts.push('ROWS');
+        }
+        else if (frameOptions & FRAMEOPTION_GROUPS) {
+            frameParts.push('GROUPS');
         }
         if (frameParts.length === 0)
             return null;
-        const boundsParts = [];
-        // Handle specific frameOptions values that have known mappings
-        if (frameOptions === 789) {
-            boundsParts.push('CURRENT ROW');
-            boundsParts.push('AND UNBOUNDED FOLLOWING');
+        let start = null;
+        if (frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
+            start = 'UNBOUNDED PRECEDING';
         }
-        else if (frameOptions === 1077) {
-            boundsParts.push('UNBOUNDED PRECEDING');
-            boundsParts.push('AND CURRENT ROW');
+        else if (frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING) {
+            start = 'UNBOUNDED FOLLOWING';
         }
-        else if (frameOptions === 18453) {
-            if (node.startOffset && node.endOffset) {
-                boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
-                boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-            }
+        else if (frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
+            start = 'CURRENT ROW';
         }
-        else if (frameOptions === 1557) {
-            boundsParts.push('CURRENT ROW');
-            boundsParts.push('AND CURRENT ROW');
+        else if (frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING && node.startOffset) {
+            start = `${this.visit(node.startOffset, context)} PRECEDING`;
         }
-        else if (frameOptions === 16917) {
-            boundsParts.push('CURRENT ROW');
-            if (node.endOffset) {
-                boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-            }
+        else if (frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING && node.startOffset) {
+            start = `${this.visit(node.startOffset, context)} FOLLOWING`;
         }
-        else if (frameOptions === 1058) {
-            return null;
+        let end = null;
+        if (frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) {
+            end = 'UNBOUNDED PRECEDING';
         }
-        else {
-            // Handle start bound - prioritize explicit offset values over bit flags
-            if (node.startOffset) {
-                if (frameOptions & 0x400) { // FRAMEOPTION_START_VALUE_PRECEDING
-                    boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
-                }
-                else if (frameOptions & 0x800) { // FRAMEOPTION_START_VALUE_FOLLOWING
-                    boundsParts.push(`${this.visit(node.startOffset, context)} FOLLOWING`);
-                }
-                else {
-                    boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
-                }
-            }
-            else if (frameOptions & 0x10) { // FRAMEOPTION_START_UNBOUNDED_PRECEDING
-                boundsParts.push('UNBOUNDED PRECEDING');
-            }
-            else if (frameOptions & 0x20) { // FRAMEOPTION_START_CURRENT_ROW
-                boundsParts.push('CURRENT ROW');
-            }
-            // Handle end bound - prioritize explicit offset values over bit flags
-            if (node.endOffset) {
-                if (boundsParts.length > 0) {
-                    if (frameOptions & 0x1000) { // FRAMEOPTION_END_VALUE_PRECEDING
-                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} PRECEDING`);
-                    }
-                    else if (frameOptions & 0x2000) { // FRAMEOPTION_END_VALUE_FOLLOWING
-                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-                    }
-                    else {
-                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-                    }
-                }
-            }
-            else if (frameOptions & 0x80) { // FRAMEOPTION_END_UNBOUNDED_FOLLOWING
-                if (boundsParts.length > 0) {
-                    boundsParts.push('AND UNBOUNDED FOLLOWING');
-                }
-            }
-            else if (frameOptions & 0x100) { // FRAMEOPTION_END_CURRENT_ROW
-                if (boundsParts.length > 0) {
-                    boundsParts.push('AND CURRENT ROW');
-                }
+        else if (frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
+            end = 'UNBOUNDED FOLLOWING';
+        }
+        else if (frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
+            end = 'CURRENT ROW';
+        }
+        else if (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING && node.endOffset) {
+            end = `${this.visit(node.endOffset, context)} PRECEDING`;
+        }
+        else if (frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING && node.endOffset) {
+            end = `${this.visit(node.endOffset, context)} FOLLOWING`;
+        }
+        if (start) {
+            if (frameOptions & FRAMEOPTION_BETWEEN) {
+                frameParts.push(`BETWEEN ${start} AND ${end ?? 'CURRENT ROW'}`);
             }
-            else if (boundsParts.length > 0) {
-                boundsParts.push('AND CURRENT ROW');
+            else {
+                frameParts.push(start);
             }
         }
-        if (boundsParts.length > 0) {
-            frameParts.push('BETWEEN');
-            frameParts.push(boundsParts.join(' '));
+        if (frameOptions & FRAMEOPTION_EXCLUDE_CURRENT_ROW) {
+            frameParts.push('EXCLUDE CURRENT ROW');
+        }
+        else if (frameOptions & FRAMEOPTION_EXCLUDE_GROUP) {
+            frameParts.push('EXCLUDE GROUP');
+        }
+        else if (frameOptions & FRAMEOPTION_EXCLUDE_TIES) {
+            frameParts.push('EXCLUDE TIES');
         }
         return frameParts.join(' ');
     }
@@ -3080,8 +3286,35 @@ class Deparser {
         if (node.ctequery) {
             output.push(context.parens(this.visit(node.ctequery, context)));
         }
+        if (node.search_clause) {
+            const sc = node.search_clause;
+            const cols = list_utils_1.ListUtils.unwrapList(sc.search_col_list).map(c => this.visit(c, context));
+            output.push('SEARCH', sc.search_breadth_first ? 'BREADTH' : 'DEPTH', 'FIRST BY');
+            output.push(cols.join(', '));
+            output.push('SET', quotes_1.QuoteUtils.quoteIdentifier(sc.search_seq_column));
+        }
+        if (node.cycle_clause) {
+            const cc = node.cycle_clause;
+            const cols = list_utils_1.ListUtils.unwrapList(cc.cycle_col_list).map(c => this.visit(c, context));
+            output.push('CYCLE', cols.join(', '));
+            output.push('SET', quotes_1.QuoteUtils.quoteIdentifier(cc.cycle_mark_column));
+            if (cc.cycle_mark_value && cc.cycle_mark_default) {
+                output.push('TO', this.formatAexprConst(cc.cycle_mark_value, context));
+                output.push('DEFAULT', this.formatAexprConst(cc.cycle_mark_default, context));
+            }
+            output.push('USING', quotes_1.QuoteUtils.quoteIdentifier(cc.cycle_path_column));
+        }
         return output.join(' ');
     }
+    // Renders a constant in the restricted AexprConst grammar (e.g. `point '(1,1)'`
+    // rather than `CAST('(1,1)' AS point)`).
+    formatAexprConst(node, context) {
+        const cast = node.TypeCast;
+        if (cast?.arg?.A_Const?.sval && cast.typeName) {
+            return `${this.TypeName(cast.typeName, context)} ${this.visit(cast.arg, context)}`;
+        }
+        return this.visit(node, context);
+    }
     ParamRef(node, context) {
         return `$${node.number}`;
     }
@@ -3331,7 +3564,7 @@ class Deparser {
             output.push('IF NOT EXISTS');
         }
         if (node.idxname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.idxname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.idxname));
         }
         output.push('ON');
         if (node.relation) {
@@ -3350,9 +3583,8 @@ class Deparser {
             output.push('INCLUDE');
             output.push(context.parens(includeStrs.join(', ')));
         }
-        if (node.whereClause) {
-            output.push('WHERE');
-            output.push(this.visit(node.whereClause, context));
+        if (node.nulls_not_distinct) {
+            output.push('NULLS NOT DISTINCT');
         }
         if (node.options && node.options.length > 0) {
             const indexContext = context.spawn('IndexStmt');
@@ -3360,19 +3592,20 @@ class Deparser {
             output.push('WITH');
             output.push(context.parens(optionStrs.join(', ')));
         }
-        if (node.nulls_not_distinct) {
-            output.push('NULLS NOT DISTINCT');
-        }
         if (node.tableSpace) {
             output.push('TABLESPACE');
-            output.push(quote_utils_1.QuoteUtils.quote(node.tableSpace));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.tableSpace));
         }
-        return output.join(' ');
-    }
+        if (node.whereClause) {
+            output.push('WHERE');
+            output.push(this.visit(node.whereClause, context));
+        }
+        return output.join(' ');
+    }
     IndexElem(node, context) {
         const output = [];
         if (node.name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
         }
         else if (node.expr) {
             output.push(context.parens(this.visit(node.expr, context)));
@@ -3390,7 +3623,7 @@ class Deparser {
                 const opclassOpts = list_utils_1.ListUtils.unwrapList(node.opclassopts).map(opt => {
                     if (opt.DefElem && opt.DefElem.arg && this.getNodeType(opt.DefElem.arg) === 'String') {
                         const stringData = this.getNodeData(opt.DefElem.arg);
-                        return `${opt.DefElem.defname}='${stringData.sval}'`;
+                        return `${quotes_1.QuoteUtils.quoteIdentifierAfterDot(opt.DefElem.defname)}=${quotes_1.QuoteUtils.escape(stringData.sval)}`;
                     }
                     return this.visit(opt, context.spawn('IndexElem'));
                 });
@@ -3423,7 +3656,7 @@ class Deparser {
     PartitionElem(node, context) {
         const output = [];
         if (node.name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
         }
         else if (node.expr) {
             output.push(context.parens(this.visit(node.expr, context)));
@@ -3441,12 +3674,12 @@ class Deparser {
     }
     PartitionCmd(node, context) {
         const output = [];
+        if (node.name) {
+            output.push(this.RangeVar(node.name, context));
+        }
         if (node.concurrent) {
             output.push('CONCURRENTLY');
         }
-        if (node.name) {
-            output.push(this.visit(node.name, context));
-        }
         if (node.bound) {
             if (node.bound.strategy === 'l' && node.bound.listdatums) {
                 output.push('FOR VALUES IN');
@@ -3471,9 +3704,9 @@ class Deparser {
                     output.push(`(${upperValues})`);
                 }
             }
-            else if (node.bound.strategy === 'h' && node.bound.modulus !== undefined && node.bound.remainder !== undefined) {
+            else if (node.bound.strategy === 'h') {
                 output.push('FOR VALUES WITH');
-                output.push(`(modulus ${node.bound.modulus}, remainder ${node.bound.remainder})`);
+                output.push(`(MODULUS ${node.bound.modulus ?? 0}, REMAINDER ${node.bound.remainder ?? 0})`);
             }
             else if (node.bound.is_default) {
                 output.push('DEFAULT');
@@ -3604,12 +3837,7 @@ class Deparser {
             if (context.isPretty()) {
                 // For complex JOIN conditions, format with proper indentation
                 if (qualsStr.includes('AND') || qualsStr.includes('OR') || qualsStr.length > 50) {
-                    if (this.containsMultilineStringLiteral(qualsStr)) {
-                        output.push(` ON ${qualsStr}`);
-                    }
-                    else {
-                        output.push(` ON${context.newline()}${context.indent(qualsStr)}`);
-                    }
+                    output.push(` ON${context.newline()}${context.indent(qualsStr)}`);
                 }
                 else {
                     output.push(` ON ${qualsStr}`);
@@ -3673,37 +3901,37 @@ class Deparser {
             case 'TRANS_STMT_SAVEPOINT':
                 output.push('SAVEPOINT');
                 if (node.savepoint_name) {
-                    output.push(quote_utils_1.QuoteUtils.quote(node.savepoint_name));
+                    output.push(quotes_1.QuoteUtils.quoteIdentifier(node.savepoint_name));
                 }
                 break;
             case 'TRANS_STMT_RELEASE':
                 output.push('RELEASE SAVEPOINT');
                 if (node.savepoint_name) {
-                    output.push(quote_utils_1.QuoteUtils.quote(node.savepoint_name));
+                    output.push(quotes_1.QuoteUtils.quoteIdentifier(node.savepoint_name));
                 }
                 break;
             case 'TRANS_STMT_ROLLBACK_TO':
                 output.push('ROLLBACK TO');
                 if (node.savepoint_name) {
-                    output.push(quote_utils_1.QuoteUtils.quote(node.savepoint_name));
+                    output.push(quotes_1.QuoteUtils.quoteIdentifier(node.savepoint_name));
                 }
                 break;
             case 'TRANS_STMT_PREPARE':
                 output.push('PREPARE TRANSACTION');
                 if (node.gid) {
-                    output.push(`'${node.gid}'`);
+                    output.push(quotes_1.QuoteUtils.escape(node.gid));
                 }
                 break;
             case 'TRANS_STMT_COMMIT_PREPARED':
                 output.push('COMMIT PREPARED');
                 if (node.gid) {
-                    output.push(`'${node.gid}'`);
+                    output.push(quotes_1.QuoteUtils.escape(node.gid));
                 }
                 break;
             case 'TRANS_STMT_ROLLBACK_PREPARED':
                 output.push('ROLLBACK PREPARED');
                 if (node.gid) {
-                    output.push(`'${node.gid}'`);
+                    output.push(quotes_1.QuoteUtils.escape(node.gid));
                 }
                 break;
             default:
@@ -3770,28 +3998,39 @@ class Deparser {
         switch (node.kind) {
             case 'VAR_SET_VALUE':
                 const localPrefix = node.is_local ? 'LOCAL ' : '';
+                if (node.jumble_args && node.name === 'xmloption' && node.args) {
+                    const xmlValue = this.getNodeData(list_utils_1.ListUtils.unwrapList(node.args)[0]);
+                    const xmlOption = (typeof xmlValue.sval === 'object' ? xmlValue.sval.sval : xmlValue.sval) || '';
+                    return `SET ${localPrefix}XML OPTION ${xmlOption.toUpperCase()}`;
+                }
                 const args = node.args ? list_utils_1.ListUtils.unwrapList(node.args).map(arg => {
                     const nodeData = this.getNodeData(arg);
                     if (nodeData.sval !== undefined) {
                         const svalValue = typeof nodeData.sval === 'object' ? nodeData.sval.sval : nodeData.sval;
-                        if (svalValue === '' || svalValue.includes(' ') || svalValue.includes('-') || /[A-Z]/.test(svalValue) || /^\d/.test(svalValue) || svalValue.includes('.') || svalValue.includes('$') || svalValue.toLowerCase() === 'all' || /^[+-]\d/.test(svalValue)) {
-                            return `'${svalValue}'`;
+                        if (!/^[a-z_][a-z0-9_]*$/.test(svalValue) || svalValue.includes(' ') || svalValue.includes('-') || /[A-Z]/.test(svalValue) || /^\d/.test(svalValue) || svalValue.includes('.') || svalValue.includes('$') || svalValue.toLowerCase() === 'all' || /^[+-]\d/.test(svalValue)) {
+                            return quotes_1.QuoteUtils.escape(svalValue);
                         }
                         return svalValue;
                     }
                     return this.visit(arg, context);
                 }).join(', ') : '';
+                if (node.jumble_args && node.name === 'timezone') {
+                    return `SET ${localPrefix}TIME ZONE ${args}`;
+                }
                 // Handle args - always include TO clause if args exist (even if empty string)
-                const paramName = node.name && (node.name.includes('.') || node.name.includes('-') || /[A-Z]/.test(node.name)) ? `"${node.name}"` : node.name;
+                const paramName = quotes_1.QuoteUtils.quoteIdentifier(node.name);
                 if (!node.args || node.args.length === 0) {
                     return `SET ${localPrefix}${paramName}`;
                 }
                 return `SET ${localPrefix}${paramName} TO ${args}`;
             case 'VAR_SET_DEFAULT':
-                const defaultParamName = node.name && (node.name.includes('.') || node.name.includes('-') || /[A-Z]/.test(node.name)) ? `"${node.name}"` : node.name;
+                if (node.jumble_args && node.name === 'timezone') {
+                    return `SET ${node.is_local ? 'LOCAL ' : ''}TIME ZONE DEFAULT`;
+                }
+                const defaultParamName = quotes_1.QuoteUtils.quoteIdentifier(node.name);
                 return `SET ${defaultParamName} TO DEFAULT`;
             case 'VAR_SET_CURRENT':
-                const currentParamName = node.name && (node.name.includes('.') || node.name.includes('-') || /[A-Z]/.test(node.name)) ? `"${node.name}"` : node.name;
+                const currentParamName = quotes_1.QuoteUtils.quoteIdentifier(node.name);
                 return `SET ${currentParamName} FROM CURRENT`;
             case 'VAR_SET_MULTI':
                 if (node.name === 'TRANSACTION' || node.name === 'SESSION CHARACTERISTICS') {
@@ -3865,7 +4104,7 @@ class Deparser {
                     return `SET ${assignments}`;
                 }
             case 'VAR_RESET':
-                const resetParamName = node.name && (node.name.includes('.') || node.name.includes('-') || /[A-Z]/.test(node.name)) ? `"${node.name}"` : node.name;
+                const resetParamName = quotes_1.QuoteUtils.quoteIdentifier(node.name);
                 return `RESET ${resetParamName}`;
             case 'VAR_RESET_ALL':
                 return 'RESET ALL';
@@ -3885,7 +4124,7 @@ class Deparser {
             output.push('IF NOT EXISTS');
         }
         if (node.schemaname) {
-            output.push(node.schemaname);
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.schemaname));
         }
         if (node.authrole) {
             output.push('AUTHORIZATION');
@@ -4092,7 +4331,7 @@ class Deparser {
                 if (objList && objList.List && objList.List.items) {
                     const items = objList.List.items.map((item) => {
                         if (item.String && item.String.sval) {
-                            return item.String.sval;
+                            return quotes_1.QuoteUtils.quoteIdentifier(item.String.sval);
                         }
                         return this.visit(item, context);
                     });
@@ -4134,7 +4373,7 @@ class Deparser {
                     if (objList && objList.List && objList.List.items) {
                         const items = objList.List.items.map((item) => {
                             if (item.String && item.String.sval) {
-                                return quote_utils_1.QuoteUtils.quote(item.String.sval);
+                                return quotes_1.QuoteUtils.quoteIdentifier(item.String.sval);
                             }
                             return this.visit(item, context);
                         }).filter((name) => name && name.trim());
@@ -4168,13 +4407,13 @@ class Deparser {
                         if (items.length === 2) {
                             const accessMethod = items[0];
                             const objectName = items[1];
-                            return `${quote_utils_1.QuoteUtils.quote(objectName)} USING ${accessMethod}`;
+                            return `${quotes_1.QuoteUtils.quoteIdentifier(objectName)} USING ${accessMethod}`;
                         }
                         else if (items.length === 3) {
                             const accessMethod = items[0];
                             const schemaName = items[1];
                             const objectName = items[2];
-                            return `${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(objectName)} USING ${accessMethod}`;
+                            return `${quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, objectName)} USING ${accessMethod}`;
                         }
                         return items.join('.');
                     }
@@ -4217,7 +4456,7 @@ class Deparser {
                     if (objList && objList.List && objList.List.items) {
                         const items = objList.List.items.map((item) => {
                             if (item.String && item.String.sval) {
-                                return quote_utils_1.QuoteUtils.quote(item.String.sval);
+                                return quotes_1.QuoteUtils.quoteIdentifier(item.String.sval);
                             }
                             return this.visit(item, context);
                         }).filter((name) => name && name.trim());
@@ -4265,7 +4504,7 @@ class Deparser {
     PLAssignStmt(node, context) {
         const output = [];
         if (node.name) {
-            let nameWithIndirection = quote_utils_1.QuoteUtils.quote(node.name);
+            let nameWithIndirection = quotes_1.QuoteUtils.quoteIdentifier(node.name);
             if (node.indirection && node.indirection.length > 0) {
                 const indirectionStr = node.indirection
                     .map((ind) => this.visit(ind, context))
@@ -4315,10 +4554,10 @@ class Deparser {
             output.push('PROGRAM');
         }
         if (node.filename) {
-            output.push(`'${node.filename}'`);
+            output.push(quotes_1.QuoteUtils.escape(node.filename));
         }
         else {
-            output.push('STDIN');
+            output.push(node.is_from ? 'STDIN' : 'STDOUT');
         }
         if (node.options && node.options.length > 0) {
             output.push('WITH');
@@ -4414,7 +4653,7 @@ class Deparser {
                             const parts = [];
                             const indentedParts = [];
                             if (colDefData.colname) {
-                                parts.push(quote_utils_1.QuoteUtils.quote(colDefData.colname));
+                                parts.push(quotes_1.QuoteUtils.quoteIdentifier(colDefData.colname));
                             }
                             if (colDefData.typeName) {
                                 parts.push(this.TypeName(colDefData.typeName, context));
@@ -4472,7 +4711,7 @@ class Deparser {
                         else {
                             const parts = [];
                             if (colDefData.colname) {
-                                parts.push(quote_utils_1.QuoteUtils.quote(colDefData.colname));
+                                parts.push(quotes_1.QuoteUtils.quoteIdentifier(colDefData.colname));
                             }
                             if (colDefData.typeName) {
                                 parts.push(this.TypeName(colDefData.typeName, context));
@@ -4526,7 +4765,7 @@ class Deparser {
                         }
                     }
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     if (node.behavior === 'DROP_CASCADE') {
                         output.push('CASCADE');
@@ -4543,13 +4782,16 @@ class Deparser {
                         output.push('ALTER COLUMN');
                     }
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('TYPE');
                     if (node.def) {
                         const nodeData = this.getNodeData(node.def);
                         if (nodeData && nodeData.typeName) {
                             output.push(this.TypeName(nodeData.typeName, context));
+                            if (nodeData.collClause) {
+                                output.push(this.CollateClause(nodeData.collClause, context));
+                            }
                             // Handle USING clause (stored in raw_default for ALTER COLUMN TYPE)
                             if (nodeData.raw_default) {
                                 output.push('USING');
@@ -4570,7 +4812,7 @@ class Deparser {
                 case 'AT_SetTableSpace':
                     output.push('SET TABLESPACE');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_AddConstraint':
@@ -4588,7 +4830,7 @@ class Deparser {
                         output.push('DROP CONSTRAINT');
                     }
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     if (node.behavior === 'DROP_CASCADE') {
                         output.push('CASCADE');
@@ -4626,7 +4868,7 @@ class Deparser {
                 case 'AT_ColumnDefault':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     if (node.def) {
                         output.push('SET DEFAULT');
@@ -4639,7 +4881,7 @@ class Deparser {
                 case 'AT_SetStorage':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('SET STORAGE');
                     if (node.def) {
@@ -4650,7 +4892,7 @@ class Deparser {
                 case 'AT_ClusterOn':
                     output.push('CLUSTER ON');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_DropCluster':
@@ -4677,21 +4919,21 @@ class Deparser {
                 case 'AT_SetNotNull':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('SET NOT NULL');
                     break;
                 case 'AT_DropNotNull':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('DROP NOT NULL');
                     break;
                 case 'AT_SetStatistics':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     else if (node.num !== undefined && node.num !== null) {
                         output.push(node.num.toString());
@@ -4704,7 +4946,7 @@ class Deparser {
                 case 'AT_SetOptions':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('SET');
                     if (node.def) {
@@ -4721,7 +4963,7 @@ class Deparser {
                 case 'AT_ResetOptions':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('RESET');
                     if (node.def) {
@@ -4738,7 +4980,7 @@ class Deparser {
                 case 'AT_SetCompression':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('SET COMPRESSION');
                     if (node.def) {
@@ -4748,31 +4990,31 @@ class Deparser {
                 case 'AT_ValidateConstraint':
                     output.push('VALIDATE CONSTRAINT');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_EnableTrig':
                     output.push('ENABLE TRIGGER');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_EnableAlwaysTrig':
                     output.push('ENABLE ALWAYS TRIGGER');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_EnableReplicaTrig':
                     output.push('ENABLE REPLICA TRIGGER');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_DisableTrig':
                     output.push('DISABLE TRIGGER');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_EnableTrigAll':
@@ -4790,31 +5032,31 @@ class Deparser {
                 case 'AT_EnableRule':
                     output.push('ENABLE RULE');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_EnableAlwaysRule':
                     output.push('ENABLE ALWAYS RULE');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_EnableReplicaRule':
                     output.push('ENABLE REPLICA RULE');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_DisableRule':
                     output.push('DISABLE RULE');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'AT_SetAccessMethod':
                     output.push('SET ACCESS METHOD');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     else {
                         // Handle DEFAULT access method case
@@ -4868,7 +5110,7 @@ class Deparser {
                 case 'AT_CookedColumnDefault':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     if (node.def) {
                         output.push('SET DEFAULT');
@@ -4881,26 +5123,23 @@ class Deparser {
                 case 'AT_SetExpression':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('SET EXPRESSION');
                     if (node.def) {
-                        output.push(this.visit(node.def, context));
+                        output.push('AS');
+                        output.push(context.parens(this.visit(node.def, context)));
                     }
                     break;
                 case 'AT_DropExpression':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('DROP EXPRESSION');
-                    break;
-                case 'AT_CheckNotNull':
-                    output.push('ALTER COLUMN');
-                    if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                    if (node.missing_ok) {
+                        output.push('IF EXISTS');
                     }
-                    output.push('SET NOT NULL');
                     break;
                 case 'AT_AddIndex':
                     output.push('ADD');
@@ -4927,23 +5166,28 @@ class Deparser {
                     }
                     break;
                 case 'AT_AlterConstraint':
-                    output.push('ALTER CONSTRAINT');
-                    if (node.def && this.getNodeType(node.def) === 'Constraint') {
-                        const constraintData = this.getNodeData(node.def);
-                        if (constraintData.conname) {
-                            output.push(quote_utils_1.QuoteUtils.quote(constraintData.conname));
-                            if (constraintData.deferrable !== undefined) {
-                                output.push(constraintData.deferrable ? 'DEFERRABLE' : 'NOT DEFERRABLE');
-                            }
-                            if (constraintData.initdeferred !== undefined) {
-                                output.push(constraintData.initdeferred ? 'INITIALLY DEFERRED' : 'INITIALLY IMMEDIATE');
+                    if (node.def && this.getNodeType(node.def) === 'ATAlterConstraint') {
+                        output.push(this.ATAlterConstraint(this.getNodeData(node.def), context));
+                    }
+                    else {
+                        output.push('ALTER CONSTRAINT');
+                        if (node.def && this.getNodeType(node.def) === 'Constraint') {
+                            const constraintData = this.getNodeData(node.def);
+                            if (constraintData.conname) {
+                                output.push(quotes_1.QuoteUtils.quoteIdentifier(constraintData.conname));
+                                if (constraintData.deferrable !== undefined) {
+                                    output.push(constraintData.deferrable ? 'DEFERRABLE' : 'NOT DEFERRABLE');
+                                }
+                                if (constraintData.initdeferred !== undefined) {
+                                    output.push(constraintData.initdeferred ? 'INITIALLY DEFERRED' : 'INITIALLY IMMEDIATE');
+                                }
                             }
                         }
-                    }
-                    else if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
-                        if (node.def) {
-                            output.push(this.visit(node.def, context));
+                        else if (node.name) {
+                            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
+                            if (node.def) {
+                                output.push(this.visit(node.def, context));
+                            }
                         }
                     }
                     break;
@@ -4962,7 +5206,7 @@ class Deparser {
                 case 'AT_AlterColumnGenericOptions':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('OPTIONS');
                     if (node.def) {
@@ -5016,7 +5260,7 @@ class Deparser {
                 case 'AT_AddIdentity':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('ADD');
                     if (node.def) {
@@ -5026,24 +5270,20 @@ class Deparser {
                 case 'AT_SetIdentity':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
-                    output.push('SET');
                     if (node.def) {
-                        output.push(this.visit(node.def, context));
+                        output.push(this.formatIdentityColumnOptions(node.def, context));
                     }
                     break;
                 case 'AT_DropIdentity':
                     output.push('ALTER COLUMN');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('DROP IDENTITY');
-                    if (node.behavior === 'DROP_CASCADE') {
-                        output.push('CASCADE');
-                    }
-                    else if (node.behavior === 'DROP_RESTRICT') {
-                        output.push('RESTRICT');
+                    if (node.missing_ok) {
+                        output.push('IF EXISTS');
                     }
                     break;
                 case 'AT_ReAddStatistics':
@@ -5070,7 +5310,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 = quotes_1.QuoteUtils.quoteDottedName(funcnameParts);
             if (node.parameters && node.parameters.length > 0) {
                 const params = node.parameters
                     .filter((param) => {
@@ -5079,7 +5320,13 @@ class Deparser {
                 })
                     .map((param) => this.visit(param, context));
                 if (params.length > 0) {
-                    output.push(funcName + '(' + params.join(', ') + ')');
+                    if (context.isPretty()) {
+                        const formattedParams = params.map(p => context.indent(p)).join(',' + context.newline());
+                        output.push(funcName + '(' + context.newline() + formattedParams + context.newline() + ')');
+                    }
+                    else {
+                        output.push(funcName + '(' + params.join(', ') + ')');
+                    }
                 }
                 else {
                     output.push(funcName + '()');
@@ -5094,15 +5341,21 @@ class Deparser {
             return paramData.mode === 'FUNC_PARAM_TABLE';
         });
         if (hasTableParams) {
-            output.push('RETURNS TABLE (');
             const tableParams = node.parameters
                 .filter((param) => {
                 const paramData = this.getNodeData(param);
                 return paramData.mode === 'FUNC_PARAM_TABLE';
             })
                 .map((param) => this.visit(param, context));
-            output.push(tableParams.join(', '));
-            output.push(')');
+            if (context.isPretty()) {
+                const formattedTableParams = tableParams.map(p => context.indent(p)).join(',' + context.newline());
+                output.push('RETURNS TABLE (' + context.newline() + formattedTableParams + context.newline() + ')');
+            }
+            else {
+                output.push('RETURNS TABLE (');
+                output.push(tableParams.join(', '));
+                output.push(')');
+            }
         }
         else if (node.returnType) {
             output.push('RETURNS');
@@ -5124,6 +5377,7 @@ class Deparser {
                 if (bodyType === 'List') {
                     const statements = list_utils_1.ListUtils.unwrapList(node.sql_body);
                     if (statements.length === 0 || (statements.length === 1 && Object.keys(statements[0]).length === 0)) {
+                        // empty body: nothing to emit
                     }
                     else {
                         // Handle nested List structure in BEGIN ATOMIC blocks
@@ -5175,7 +5429,7 @@ class Deparser {
             }
         }
         if (node.name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
         }
         if (node.argType) {
             output.push(this.TypeName(node.argType, context));
@@ -5247,7 +5501,7 @@ class Deparser {
             output.push('ROLE');
         }
         if (node.role) {
-            const roleName = Deparser.needsQuotes(node.role) ? `"${node.role}"` : node.role;
+            const roleName = quotes_1.QuoteUtils.quoteIdentifier(node.role);
             output.push(roleName);
         }
         if (node.options) {
@@ -5271,25 +5525,28 @@ class Deparser {
             if (node.arg && this.getNodeType(node.arg) === 'List') {
                 const listData = this.getNodeData(node.arg);
                 const listItems = list_utils_1.ListUtils.unwrapList(listData.items);
+                const preservedName = this.preserveOperatorDefElemCase(node.defname);
                 if (listItems.length === 1 && listItems[0].String) {
-                    const preservedName = this.preserveOperatorDefElemCase(node.defname);
                     return `${preservedName} = ${listItems[0].String.sval}`;
                 }
+                if (listItems.length > 1 && listItems.every((item) => item.String)) {
+                    return `${preservedName} = OPERATOR(${this.qualifiedOperatorName(listItems)})`;
+                }
             }
         }
         // Handle IndexElem opclassopts - MUST be first to preserve string types
         if (context.parentNodeTypes.includes('IndexElem')) {
             if (node.arg && this.getNodeType(node.arg) === 'String') {
                 const stringData = this.getNodeData(node.arg);
-                return `${node.defname}='${stringData.sval}'`;
+                return `${quotes_1.QuoteUtils.quoteIdentifierAfterDot(node.defname)}=${quotes_1.QuoteUtils.escape(stringData.sval)}`;
             }
-            return `${node.defname}=${this.visit(node.arg, context.spawn('DefElem'))}`;
+            return `${quotes_1.QuoteUtils.quoteIdentifierAfterDot(node.defname)}=${this.formatOptionValue(node.arg, this.visit(node.arg, context.spawn('DefElem')))}`;
         }
         // Handle CREATE OPERATOR boolean flags - MUST be first to preserve case
         if (context.parentNodeTypes.includes('DefineStmt') &&
             ['hashes', 'merges'].includes(node.defname.toLowerCase()) && !node.arg) {
             if (node.defname !== node.defname.toLowerCase() && node.defname !== node.defname.toUpperCase()) {
-                return `"${node.defname}"`;
+                return quotes_1.QuoteUtils.quoteIdentifier(node.defname);
             }
             return node.defname.charAt(0).toUpperCase() + node.defname.slice(1).toLowerCase();
         }
@@ -5308,12 +5565,8 @@ class Deparser {
                 const defElemContext = context.spawn('DefElem');
                 const argValue = this.visit(node.arg, defElemContext);
                 if (context.parentNodeTypes.includes('CreateFdwStmt') || context.parentNodeTypes.includes('AlterFdwStmt')) {
-                    const finalValue = typeof argValue === 'string' && !argValue.startsWith("'")
-                        ? `'${argValue}'`
-                        : argValue;
-                    const quotedDefname = node.defname.includes(' ') || node.defname.includes('-') || Deparser.needsQuotes(node.defname)
-                        ? `"${node.defname}"`
-                        : node.defname;
+                    const finalValue = this.quoteDefElemArg(node.arg, argValue);
+                    const quotedDefname = quotes_1.QuoteUtils.quoteIdentifier(node.defname);
                     if (node.defaction === 'DEFELEM_ADD') {
                         return `ADD ${quotedDefname} ${finalValue}`;
                     }
@@ -5325,9 +5578,7 @@ class Deparser {
                     }
                     return `${quotedDefname} ${finalValue}`;
                 }
-                const quotedValue = typeof argValue === 'string' && !argValue.startsWith("'")
-                    ? `'${argValue}'`
-                    : argValue;
+                const quotedValue = this.quoteDefElemArg(node.arg, argValue);
                 if (node.defaction === 'DEFELEM_ADD') {
                     return `ADD ${node.defname} ${quotedValue}`;
                 }
@@ -5337,9 +5588,7 @@ class Deparser {
                 else if (node.defaction === 'DEFELEM_SET') {
                     return `SET ${node.defname} ${quotedValue}`;
                 }
-                const quotedDefname = node.defname.includes(' ') || node.defname.includes('-')
-                    ? `"${node.defname}"`
-                    : node.defname;
+                const quotedDefname = quotes_1.QuoteUtils.quoteIdentifier(node.defname);
                 return `${quotedDefname} ${quotedValue}`;
             }
             else if (node.defaction === 'DEFELEM_DROP') {
@@ -5361,9 +5610,7 @@ class Deparser {
                 }
                 const defElemContext = context.spawn('DefElem');
                 const argValue = this.visit(node.arg, defElemContext);
-                const quotedValue = typeof argValue === 'string' && !argValue.startsWith("'")
-                    ? `'${argValue}'`
-                    : argValue;
+                const quotedValue = this.quoteDefElemArg(node.arg, argValue);
                 return `PASSWORD ${quotedValue}`;
             }
         }
@@ -5386,22 +5633,23 @@ class Deparser {
                     if (listItems.length === 1 && listItems[0].String) {
                         return `${node.defname} = ${listItems[0].String.sval}`;
                     }
+                    if (listItems.length > 1 && listItems.every((item) => item.String)) {
+                        return `${node.defname} = OPERATOR(${this.qualifiedOperatorName(listItems)})`;
+                    }
                 }
             }
             if (context.parentNodeTypes.includes('CreatedbStmt') || context.parentNodeTypes.includes('DropdbStmt')) {
                 const quotedValue = typeof argValue === 'string'
-                    ? quote_utils_1.QuoteUtils.escape(argValue)
+                    ? quotes_1.QuoteUtils.escape(argValue)
                     : argValue;
                 return `${node.defname} = ${quotedValue}`;
             }
             // CreateForeignServerStmt and AlterForeignServerStmt use space format like CreateFdwStmt
             if (context.parentNodeTypes.includes('CreateForeignServerStmt') || context.parentNodeTypes.includes('AlterForeignServerStmt')) {
                 const quotedValue = typeof argValue === 'string'
-                    ? quote_utils_1.QuoteUtils.escape(argValue)
+                    ? quotes_1.QuoteUtils.escape(argValue)
                     : argValue;
-                const quotedDefname = node.defname.includes(' ') || node.defname.includes('-')
-                    ? `"${node.defname}"`
-                    : node.defname;
+                const quotedDefname = quotes_1.QuoteUtils.quoteIdentifier(node.defname);
                 return `${quotedDefname} ${quotedValue}`;
             }
             if (context.parentNodeTypes.includes('CreateRoleStmt') || context.parentNodeTypes.includes('AlterRoleStmt')) {
@@ -5430,9 +5678,7 @@ class Deparser {
                     }
                 }
                 if (node.defname === 'validUntil') {
-                    const quotedValue = typeof argValue === 'string' && !argValue.startsWith("'")
-                        ? `'${argValue}'`
-                        : argValue;
+                    const quotedValue = this.quoteDefElemArg(node.arg, argValue);
                     return `VALID UNTIL ${quotedValue}`;
                 }
                 if (node.defname === 'adminmembers') {
@@ -5471,15 +5717,15 @@ class Deparser {
                     if (node.arg && this.getNodeType(node.arg) === 'List') {
                         const listData = this.getNodeData(node.arg);
                         const listItems = list_utils_1.ListUtils.unwrapList(listData.items);
+                        if (listItems.length === 1 && listItems[0].String?.sval === 'none') {
+                            return 'OWNED BY NONE';
+                        }
                         const parts = listItems.map(item => {
                             const itemData = this.getNodeData(item);
                             if (this.getNodeType(item) === 'String') {
                                 // Check if this identifier needs quotes to preserve case
                                 const value = itemData.sval;
-                                if (Deparser.needsQuotes(value)) {
-                                    return `"${value}"`;
-                                }
-                                return value;
+                                return quotes_1.QuoteUtils.quoteIdentifier(value);
                             }
                             return this.visit(item, context);
                         });
@@ -5610,11 +5856,13 @@ class Deparser {
             if (context.parentNodeTypes.includes('CreateExtensionStmt') || context.parentNodeTypes.includes('AlterExtensionStmt') || context.parentNodeTypes.includes('CreateFdwStmt') || context.parentNodeTypes.includes('AlterFdwStmt')) {
                 // AlterExtensionStmt specific cases
                 if (context.parentNodeTypes.includes('AlterExtensionStmt')) {
-                    if (node.defname === 'to') {
-                        return `TO ${argValue}`;
+                    if (node.defname === 'new_version') {
+                        // argValue is unquoted due to DefElem context, so we need to quote it
+                        const quotedValue = this.quoteDefElemArg(node.arg, argValue);
+                        return `TO ${quotedValue}`;
                     }
                     if (node.defname === 'schema') {
-                        return `SCHEMA ${argValue}`;
+                        return `SET SCHEMA ${argValue}`;
                     }
                 }
                 // CreateFdwStmt specific cases
@@ -5623,7 +5871,7 @@ class Deparser {
                         return `${node.defname.toUpperCase()} ${argValue}`;
                     }
                     const quotedValue = typeof argValue === 'string'
-                        ? quote_utils_1.QuoteUtils.escape(argValue)
+                        ? quotes_1.QuoteUtils.escape(argValue)
                         : argValue;
                     return `${node.defname} ${quotedValue}`;
                 }
@@ -5631,28 +5879,37 @@ class Deparser {
                 if (node.defname === 'cascade') {
                     return argValue === 'true' ? 'CASCADE' : '';
                 }
+                if (node.defname === 'new_version') {
+                    return `VERSION ${this.quoteDefElemArg(node.arg, argValue)}`;
+                }
+                if (node.defname === 'schema' && node.arg && this.getNodeType(node.arg) === 'String') {
+                    return `SCHEMA ${quotes_1.QuoteUtils.quoteIdentifier(this.getNodeData(node.arg).sval)}`;
+                }
                 return `${node.defname.toUpperCase()} ${argValue}`;
             }
             // Handle IndexStmt WITH clause options - no quotes, compact formatting
             if (context.parentNodeTypes.includes('IndexStmt')) {
-                return `${node.defname}=${argValue}`;
+                return `${quotes_1.QuoteUtils.quoteIdentifierAfterDot(node.defname)}=${this.formatOptionValue(node.arg, argValue)}`;
             }
             // Handle IndexElem opclassopts - preserve string values as strings
             if (context.parentNodeTypes.includes('IndexElem')) {
                 if (node.arg && this.getNodeType(node.arg) === 'String') {
                     const stringData = this.getNodeData(node.arg);
-                    return `${node.defname}='${stringData.sval}'`;
+                    return `${quotes_1.QuoteUtils.quoteIdentifierAfterDot(node.defname)}=${quotes_1.QuoteUtils.escape(stringData.sval)}`;
                 }
-                return `${node.defname}=${argValue}`;
+                return `${quotes_1.QuoteUtils.quoteIdentifierAfterDot(node.defname)}=${this.formatOptionValue(node.arg, argValue)}`;
             }
             // Handle CreateStmt table options - no quotes, compact formatting
             if (context.parentNodeTypes.includes('CreateStmt')) {
+                const relOptName = node.defnamespace
+                    ? `${quotes_1.QuoteUtils.quoteIdentifier(node.defnamespace)}.${quotes_1.QuoteUtils.quoteIdentifier(node.defname)}`
+                    : quotes_1.QuoteUtils.quoteIdentifier(node.defname);
                 // For numeric values, use the raw value without quotes
                 if (node.arg && this.getNodeType(node.arg) === 'Integer') {
                     const integerData = this.getNodeData(node.arg);
-                    return `${node.defname}=${integerData.ival}`;
+                    return `${relOptName}=${formatInteger(integerData.ival)}`;
                 }
-                return `${node.defname}=${argValue}`;
+                return `${relOptName}=${this.formatOptionValue(node.arg, argValue)}`;
             }
             // Handle CreateEventTrigStmt WHEN clause - use IN syntax for List arguments
             if (context.parentNodeTypes.includes('CreateEventTrigStmt')) {
@@ -5662,7 +5919,7 @@ class Deparser {
                     const values = listItems.map(item => {
                         if (this.getNodeType(item) === 'String') {
                             const stringData = this.getNodeData(item);
-                            return `'${stringData.sval || ''}'`;
+                            return quotes_1.QuoteUtils.escape(stringData.sval || '');
                         }
                         return this.visit(item, context);
                     });
@@ -5677,7 +5934,7 @@ class Deparser {
                 if (node.arg && this.getNodeType(node.arg) === 'TypeName') {
                     return `${optionName} = ${argValue}`;
                 }
-                return `${optionName} = ${argValue}`;
+                return `${optionName} = ${this.formatOptionValue(node.arg, argValue)}`;
             }
             // Handle ViewStmt WITH options - don't quote numeric values
             if (context.parentNodeTypes.includes('ViewStmt')) {
@@ -5685,21 +5942,33 @@ class Deparser {
                     return `${node.defname}=${argValue}`;
                 }
                 const quotedValue = typeof argValue === 'string'
-                    ? quote_utils_1.QuoteUtils.escape(argValue)
+                    ? quotes_1.QuoteUtils.escape(argValue)
                     : argValue;
                 return `${node.defname} = ${quotedValue}`;
             }
             // Handle CopyStmt WITH clause options - uppercase format without quotes
             if (context.parentNodeTypes.includes('CopyStmt')) {
-                if (node.defname === 'format' && node.arg && this.getNodeType(node.arg) === 'String') {
-                    const stringData = this.getNodeData(node.arg);
-                    return `FORMAT ${stringData.sval.toUpperCase()}`;
+                const optName = node.defname.toUpperCase();
+                if (!node.arg) {
+                    return optName;
                 }
-                // Handle other COPY options with uppercase defname
-                if (node.arg) {
-                    return `${node.defname.toUpperCase()} ${argValue}`;
+                const copyArgType = this.getNodeType(node.arg);
+                if (copyArgType === 'Boolean' && this.getNodeData(node.arg).boolval !== false) {
+                    return optName;
                 }
-                return node.defname.toUpperCase();
+                if (copyArgType === 'List') {
+                    const items = list_utils_1.ListUtils.unwrapList(this.getNodeData(node.arg).items)
+                        .map(item => this.visit(item, context));
+                    return `${optName} (${items.join(', ')})`;
+                }
+                if (copyArgType === 'String') {
+                    const sval = this.getNodeData(node.arg).sval;
+                    if (node.defname === 'format') {
+                        return `${optName} ${sval}`;
+                    }
+                    return `${optName} ${quotes_1.QuoteUtils.escape(sval)}`;
+                }
+                return `${optName} ${argValue}`;
             }
             // Handle CREATE OPERATOR and CREATE TYPE context
             if (context.parentNodeTypes.includes('DefineStmt')) {
@@ -5723,13 +5992,13 @@ class Deparser {
                 // Handle boolean flags (no arguments) - preserve quoted case
                 if (['hashes', 'merges'].includes(node.defname.toLowerCase())) {
                     if (node.defname !== node.defname.toLowerCase() && node.defname !== node.defname.toUpperCase()) {
-                        return `"${node.defname}"`;
+                        return quotes_1.QuoteUtils.quoteIdentifier(node.defname);
                     }
                     return preservedName.toUpperCase();
                 }
                 // Handle CREATE AGGREGATE quoted identifiers - preserve quotes when needed
-                if (Deparser.needsQuotes(node.defname)) {
-                    const quotedDefname = `"${node.defname}"`;
+                const quotedDefname = quotes_1.QuoteUtils.quoteIdentifier(node.defname);
+                if (quotedDefname !== node.defname) {
                     if (node.arg) {
                         if (this.getNodeType(node.arg) === 'String') {
                             const stringData = this.getNodeData(node.arg);
@@ -5738,7 +6007,7 @@ class Deparser {
                                 return `${quotedDefname} = ${stringData.sval}`;
                             }
                             // Regular string literals get single quotes
-                            return `${quotedDefname} = '${stringData.sval}'`;
+                            return `${quotedDefname} = ${quotes_1.QuoteUtils.escape(stringData.sval)}`;
                         }
                         return `${quotedDefname} = ${argValue}`;
                     }
@@ -5759,7 +6028,7 @@ class Deparser {
                         return `${node.defname} = ${stringData.sval}`;
                     }
                     // Regular string literals get single quotes
-                    return `${node.defname} = '${stringData.sval}'`;
+                    return `${node.defname} = ${quotes_1.QuoteUtils.escape(stringData.sval)}`;
                 }
                 if (node.arg && this.getNodeType(node.arg) === 'Boolean') {
                     const boolData = this.getNodeData(node.arg);
@@ -5780,8 +6049,12 @@ class Deparser {
                     return `${node.defname} = ${argValue}`;
                 }
             }
+            const argType = this.getNodeType(node.arg);
+            if (argType === 'TypeName' || argType === 'Integer' || argType === 'Float' || argType === 'Boolean') {
+                return `${node.defname} = ${argValue}`;
+            }
             const quotedValue = typeof argValue === 'string'
-                ? quote_utils_1.QuoteUtils.escape(argValue)
+                ? quotes_1.QuoteUtils.escape(argValue)
                 : argValue;
             return `${node.defname} = ${quotedValue}`;
         }
@@ -5789,7 +6062,7 @@ class Deparser {
         if (context.parentNodeTypes.includes('DefineStmt') && !node.arg) {
             // Check if the original defname appears to be quoted (mixed case that's not all upper/lower)
             if (node.defname !== node.defname.toLowerCase() && node.defname !== node.defname.toUpperCase()) {
-                return `"${node.defname}"`;
+                return quotes_1.QuoteUtils.quoteIdentifier(node.defname);
             }
         }
         return node.defname.toUpperCase();
@@ -5805,7 +6078,7 @@ class Deparser {
         }
         if (node.location) {
             output.push('LOCATION');
-            output.push(`'${node.location}'`);
+            output.push(quotes_1.QuoteUtils.escape(node.location));
         }
         if (node.options && node.options.length > 0) {
             output.push('WITH');
@@ -5869,6 +6142,7 @@ class Deparser {
         if (node.extname) {
             output.push(this.quoteIfNeeded(node.extname));
         }
+        output.push('UPDATE');
         if (node.options && node.options.length > 0) {
             const extContext = context.spawn('AlterExtensionStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options)
@@ -5878,6 +6152,34 @@ class Deparser {
         }
         return output.join(' ');
     }
+    AlterExtensionContentsStmt(node, context) {
+        const output = ['ALTER', 'EXTENSION'];
+        if (node.extname) {
+            output.push(this.quoteIfNeeded(node.extname));
+        }
+        // Handle action: 1 = ADD, -1 = DROP
+        if (node.action === 1) {
+            output.push('ADD');
+        }
+        else if (node.action === -1) {
+            output.push('DROP');
+        }
+        // Add object type keyword
+        if (node.objtype) {
+            try {
+                output.push(this.getObjectTypeKeyword(node.objtype));
+            }
+            catch {
+                // Fallback to the raw objtype if not supported
+                output.push(node.objtype.toString());
+            }
+        }
+        // Add the object itself
+        if (node.object) {
+            output.push(this.visit(node.object, context));
+        }
+        return output.join(' ');
+    }
     CreateFdwStmt(node, context) {
         const output = ['CREATE', 'FOREIGN', 'DATA', 'WRAPPER'];
         if (node.fdwname) {
@@ -5945,7 +6247,7 @@ class Deparser {
                 case 'REPLICA_IDENTITY_INDEX':
                     output.push('USING', 'INDEX');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 default:
@@ -6004,7 +6306,7 @@ class Deparser {
                         output.push('IF', 'EXISTS');
                     }
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     if (node.behavior === 'DROP_CASCADE') {
                         output.push('CASCADE');
@@ -6013,7 +6315,7 @@ class Deparser {
                 case 'AT_ValidateConstraint':
                     output.push('VALIDATE', 'CONSTRAINT');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'C':
@@ -6030,7 +6332,7 @@ class Deparser {
                         output.push('IF', 'EXISTS');
                     }
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     if (node.behavior === 'DROP_CASCADE') {
                         output.push('CASCADE');
@@ -6039,7 +6341,7 @@ class Deparser {
                 case 'V':
                     output.push('VALIDATE', 'CONSTRAINT');
                     if (node.name) {
-                        output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     break;
                 case 'O':
@@ -6110,7 +6412,7 @@ class Deparser {
         }
         if (node.payload !== null && node.payload !== undefined) {
             output.push(',');
-            output.push(`'${node.payload}'`);
+            output.push(quotes_1.QuoteUtils.escape(node.payload));
         }
         return output.join(' ');
     }
@@ -6138,7 +6440,7 @@ class Deparser {
         if (!node.filename) {
             throw new Error('LoadStmt requires filename');
         }
-        return `LOAD '${node.filename}'`;
+        return `LOAD ${quotes_1.QuoteUtils.escape(node.filename)}`;
     }
     DiscardStmt(node, context) {
         switch (node.target) {
@@ -6154,6 +6456,13 @@ class Deparser {
                 throw new Error(`Unsupported DiscardStmt target: ${node.target}`);
         }
     }
+    /** `schema.op` for an operator name list: schema parts quoted, the operator symbol as is. */
+    qualifiedOperatorName(objname) {
+        const names = list_utils_1.ListUtils.unwrapList(objname ?? []).map((n) => (n.String ? n.String.sval : 'unknown'));
+        if (names.length === 0)
+            return 'unknown';
+        return [...names.slice(0, -1).map((n) => quotes_1.QuoteUtils.quoteIdentifier(n)), names[names.length - 1]].join('.');
+    }
     CommentStmt(node, context) {
         const output = ['COMMENT ON'];
         if (node.objtype) {
@@ -6185,6 +6494,9 @@ class Deparser {
                 case 'OBJECT_TABCONSTRAINT':
                     output.push('CONSTRAINT');
                     break;
+                case 'OBJECT_DOMCONSTRAINT':
+                    output.push('CONSTRAINT');
+                    break;
                 case 'OBJECT_TRIGGER':
                     output.push('TRIGGER');
                     break;
@@ -6261,23 +6573,30 @@ class Deparser {
                             output.push(objectParts.join('.'));
                         }
                     }
-                    else if (node.objtype === 'OBJECT_TRIGGER') {
+                    else if (node.objtype === 'OBJECT_DOMCONSTRAINT') {
                         if (objectParts.length === 2) {
-                            const [table, trigger] = objectParts;
-                            output.push(trigger);
+                            const [domain, constraint] = objectParts;
+                            output.push(constraint, 'ON DOMAIN', domain);
+                        }
+                        else {
+                            output.push(objectParts.join('.'));
+                        }
+                    }
+                    else if (node.objtype === 'OBJECT_TRIGGER') {
+                        if (objectParts.length >= 2) {
+                            output.push(objectParts[objectParts.length - 1]);
                             output.push('ON');
-                            output.push(table);
+                            output.push(objectParts.slice(0, -1).join('.'));
                         }
                         else {
                             output.push(objectParts.join('.'));
                         }
                     }
                     else if (node.objtype === 'OBJECT_RULE') {
-                        if (objectParts.length === 2) {
-                            const [table, rule] = objectParts;
-                            output.push(rule);
+                        if (objectParts.length >= 2) {
+                            output.push(objectParts[objectParts.length - 1]);
                             output.push('ON');
-                            output.push(table);
+                            output.push(objectParts.slice(0, -1).join('.'));
                         }
                         else {
                             output.push(objectParts.join('.'));
@@ -6288,8 +6607,7 @@ class Deparser {
                         // For operators, we need to handle ObjectWithArgs structure
                         if (node.object && node.object.ObjectWithArgs) {
                             const objWithArgs = node.object.ObjectWithArgs;
-                            let operatorName = objWithArgs.objname && objWithArgs.objname[0] && objWithArgs.objname[0].String
-                                ? objWithArgs.objname[0].String.sval : 'unknown';
+                            let operatorName = this.qualifiedOperatorName(objWithArgs.objname);
                             if (operatorName.startsWith('"') && operatorName.endsWith('"')) {
                                 operatorName = operatorName.slice(1, -1);
                             }
@@ -6327,7 +6645,13 @@ class Deparser {
                     }
                     else if (node.objtype === 'OBJECT_POLICY') {
                         // Handle POLICY syntax: COMMENT ON POLICY policy_name ON table_name IS 'comment'
-                        if (objectParts.length === 2) {
+                        if (objectParts.length === 3) {
+                            const [schema, table, policy] = objectParts;
+                            output.push(policy);
+                            output.push('ON');
+                            output.push(`${schema}.${table}`);
+                        }
+                        else if (objectParts.length === 2) {
                             const [table, policy] = objectParts;
                             output.push(policy);
                             output.push('ON');
@@ -6350,6 +6674,9 @@ class Deparser {
                             output.push(objectParts.join('.'));
                         }
                     }
+                    else if (node.objtype === 'OBJECT_CAST' && objectParts.length === 2) {
+                        output.push(`(${objectParts[0]} AS ${objectParts[1]})`);
+                    }
                     else {
                         output.push(objectParts.join('.'));
                     }
@@ -6358,8 +6685,7 @@ class Deparser {
             else if (node.objtype === 'OBJECT_OPERATOR' && node.object && node.object.ObjectWithArgs) {
                 // Handle direct ObjectWithArgs for OPERATOR syntax: COMMENT ON OPERATOR -(NONE, integer) IS 'comment'
                 const objWithArgs = node.object.ObjectWithArgs;
-                let operatorName = objWithArgs.objname && objWithArgs.objname[0] && objWithArgs.objname[0].String
-                    ? objWithArgs.objname[0].String.sval : 'unknown';
+                let operatorName = this.qualifiedOperatorName(objWithArgs.objname);
                 // Remove quotes from operator name if present
                 if (operatorName.startsWith('"') && operatorName.endsWith('"')) {
                     operatorName = operatorName.slice(1, -1);
@@ -6391,7 +6717,7 @@ class Deparser {
             output.push('NULL');
         }
         else if (node.comment) {
-            output.push(quote_utils_1.QuoteUtils.formatEString(node.comment));
+            output.push(quotes_1.QuoteUtils.formatEString(node.comment));
         }
         return output.join(' ');
     }
@@ -6428,7 +6754,7 @@ class Deparser {
         const output = [];
         const initialParts = ['CREATE', 'POLICY'];
         if (node.policy_name) {
-            initialParts.push(quote_utils_1.QuoteUtils.quote(node.policy_name));
+            initialParts.push(quotes_1.QuoteUtils.quoteIdentifier(node.policy_name));
         }
         output.push(initialParts.join(' '));
         // Add ON clause on new line in pretty mode
@@ -6505,7 +6831,7 @@ class Deparser {
     AlterPolicyStmt(node, context) {
         const output = ['ALTER', 'POLICY'];
         if (node.policy_name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.policy_name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.policy_name));
         }
         if (node.table) {
             output.push('ON');
@@ -6541,7 +6867,7 @@ class Deparser {
         }
         output.push('SERVER');
         if (node.servername) {
-            output.push(`"${node.servername}"`);
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.servername));
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
@@ -6589,10 +6915,10 @@ class Deparser {
     CreatePublicationStmt(node, context) {
         const output = ['CREATE', 'PUBLICATION'];
         if (node.pubname) {
-            output.push(`"${node.pubname}"`);
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.pubname));
         }
         if (node.pubobjects && node.pubobjects.length > 0) {
-            output.push('FOR', 'TABLE');
+            output.push('FOR');
             const tables = list_utils_1.ListUtils.unwrapList(node.pubobjects).map(table => this.visit(table, context));
             output.push(tables.join(', '));
         }
@@ -6609,11 +6935,11 @@ class Deparser {
     CreateSubscriptionStmt(node, context) {
         const output = ['CREATE', 'SUBSCRIPTION'];
         if (node.subname) {
-            output.push(`"${node.subname}"`);
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.subname));
         }
         output.push('CONNECTION');
         if (node.conninfo) {
-            output.push(`'${node.conninfo}'`);
+            output.push(quotes_1.QuoteUtils.escape(node.conninfo));
         }
         output.push('PUBLICATION');
         if (node.publication && node.publication.length > 0) {
@@ -6630,10 +6956,11 @@ class Deparser {
     AlterPublicationStmt(node, context) {
         const output = ['ALTER', 'PUBLICATION'];
         if (node.pubname) {
-            output.push(`"${node.pubname}"`);
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.pubname));
         }
-        if (node.action) {
-            switch (node.action) {
+        const hasObjects = node.pubobjects && node.pubobjects.length > 0;
+        if (hasObjects) {
+            switch (node.action || 'AP_AddObjects') {
                 case 'AP_AddObjects':
                     output.push('ADD');
                     break;
@@ -6646,17 +6973,11 @@ class Deparser {
                 default:
                     throw new Error(`Unsupported AlterPublicationStmt action: ${node.action}`);
             }
-        }
-        if (node.for_all_tables) {
-            output.push('FOR ALL TABLES');
-        }
-        else if (node.pubobjects && node.pubobjects.length > 0) {
-            output.push('FOR TABLE');
             const objects = list_utils_1.ListUtils.unwrapList(node.pubobjects).map(obj => this.visit(obj, context));
             output.push(objects.join(', '));
         }
-        if (node.options && node.options.length > 0) {
-            output.push('WITH');
+        else if (node.options && node.options.length > 0) {
+            output.push('SET');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, context));
             output.push(`(${options.join(', ')})`);
         }
@@ -6665,44 +6986,69 @@ class Deparser {
     AlterSubscriptionStmt(node, context) {
         const output = ['ALTER', 'SUBSCRIPTION'];
         if (node.subname) {
-            output.push(`"${node.subname}"`);
-        }
-        if (node.kind) {
-            switch (node.kind) {
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.subname));
+        }
+        const options = node.options && node.options.length > 0
+            ? `(${list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, context)).join(', ')})`
+            : null;
+        const publications = node.publication && node.publication.length > 0
+            ? list_utils_1.ListUtils.unwrapList(node.publication).map(pub => this.visit(pub, context)).join(', ')
+            : null;
+        {
+            switch (node.kind || 'ALTER_SUBSCRIPTION_OPTIONS') {
                 case 'ALTER_SUBSCRIPTION_OPTIONS':
                     output.push('SET');
+                    if (options)
+                        output.push(options);
                     break;
                 case 'ALTER_SUBSCRIPTION_CONNECTION':
                     output.push('CONNECTION');
                     if (node.conninfo) {
-                        output.push(`'${node.conninfo}'`);
+                        output.push(quotes_1.QuoteUtils.escape(node.conninfo));
                     }
                     break;
                 case 'ALTER_SUBSCRIPTION_SET_PUBLICATION':
                     output.push('SET PUBLICATION');
-                    if (node.publication && node.publication.length > 0) {
-                        const publications = list_utils_1.ListUtils.unwrapList(node.publication).map(pub => this.visit(pub, context));
-                        output.push(publications.join(', '));
-                    }
+                    if (publications)
+                        output.push(publications);
+                    if (options)
+                        output.push('WITH', options);
+                    break;
+                case 'ALTER_SUBSCRIPTION_ADD_PUBLICATION':
+                    output.push('ADD PUBLICATION');
+                    if (publications)
+                        output.push(publications);
+                    if (options)
+                        output.push('WITH', options);
+                    break;
+                case 'ALTER_SUBSCRIPTION_DROP_PUBLICATION':
+                    output.push('DROP PUBLICATION');
+                    if (publications)
+                        output.push(publications);
+                    if (options)
+                        output.push('WITH', options);
                     break;
                 case 'ALTER_SUBSCRIPTION_REFRESH':
                     output.push('REFRESH PUBLICATION');
+                    if (options)
+                        output.push('WITH', options);
                     break;
-                case 'ALTER_SUBSCRIPTION_ENABLED':
-                    output.push('ENABLE');
+                case 'ALTER_SUBSCRIPTION_ENABLED': {
+                    const enabled = list_utils_1.ListUtils.unwrapList(node.options).find(opt => opt.DefElem?.defname === 'enabled');
+                    const arg = enabled?.DefElem?.arg;
+                    const isEnabled = arg?.Boolean ? arg.Boolean.boolval !== false : true;
+                    output.push(isEnabled ? 'ENABLE' : 'DISABLE');
                     break;
+                }
                 case 'ALTER_SUBSCRIPTION_SKIP':
                     output.push('SKIP');
+                    if (options)
+                        output.push(options);
                     break;
                 default:
                     throw new Error(`Unsupported AlterSubscriptionStmt kind: ${node.kind}`);
             }
         }
-        if (node.options && node.options.length > 0) {
-            output.push('WITH');
-            const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, context));
-            output.push(`(${options.join(', ')})`);
-        }
         return output.join(' ');
     }
     DropSubscriptionStmt(node, context) {
@@ -6711,7 +7057,7 @@ class Deparser {
             output.push('IF EXISTS');
         }
         if (node.subname) {
-            output.push(`"${node.subname}"`);
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.subname));
         }
         if (node.behavior) {
             switch (node.behavior) {
@@ -6956,7 +7302,7 @@ class Deparser {
     ClosePortalStmt(node, context) {
         const output = ['CLOSE'];
         if (node.portalname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.portalname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.portalname));
         }
         else {
             output.push('ALL');
@@ -7014,7 +7360,7 @@ class Deparser {
             output.push('ALL');
         }
         if (node.portalname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.portalname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.portalname));
         }
         return output.join(' ');
     }
@@ -7084,7 +7430,7 @@ class Deparser {
     AlterFdwStmt(node, context) {
         const output = ['ALTER', 'FOREIGN', 'DATA', 'WRAPPER'];
         if (node.fdwname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.fdwname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.fdwname));
         }
         if (node.func_options && node.func_options.length > 0) {
             const fdwContext = context.spawn('AlterFdwStmt');
@@ -7105,16 +7451,16 @@ class Deparser {
             output.push('IF', 'NOT', 'EXISTS');
         }
         if (node.servername) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.servername));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.servername));
         }
         if (node.servertype) {
-            output.push('TYPE', quote_utils_1.QuoteUtils.escape(node.servertype));
+            output.push('TYPE', quotes_1.QuoteUtils.escape(node.servertype));
         }
         if (node.version) {
-            output.push('VERSION', quote_utils_1.QuoteUtils.escape(node.version));
+            output.push('VERSION', quotes_1.QuoteUtils.escape(node.version));
         }
         if (node.fdwname) {
-            output.push('FOREIGN', 'DATA', 'WRAPPER', quote_utils_1.QuoteUtils.quote(node.fdwname));
+            output.push('FOREIGN', 'DATA', 'WRAPPER', quotes_1.QuoteUtils.quoteIdentifier(node.fdwname));
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
@@ -7129,10 +7475,10 @@ class Deparser {
     AlterForeignServerStmt(node, context) {
         const output = ['ALTER', 'SERVER'];
         if (node.servername) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.servername));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.servername));
         }
         if (node.version) {
-            output.push('VERSION', quote_utils_1.QuoteUtils.escape(node.version));
+            output.push('VERSION', quotes_1.QuoteUtils.escape(node.version));
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
@@ -7154,7 +7500,7 @@ class Deparser {
         }
         output.push('SERVER');
         if (node.servername) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.servername));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.servername));
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
@@ -7178,14 +7524,14 @@ class Deparser {
         }
         output.push('SERVER');
         if (node.servername) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.servername));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.servername));
         }
         return output.join(' ');
     }
     ImportForeignSchemaStmt(node, context) {
         const output = ['IMPORT', 'FOREIGN', 'SCHEMA'];
         if (node.remote_schema) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.remote_schema));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.remote_schema));
         }
         if (node.list_type) {
             switch (node.list_type) {
@@ -7211,11 +7557,11 @@ class Deparser {
         }
         output.push('FROM', 'SERVER');
         if (node.server_name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.server_name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.server_name));
         }
         output.push('INTO');
         if (node.local_schema) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.local_schema));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.local_schema));
         }
         if (node.options && node.options.length > 0) {
             const importSchemaContext = context.spawn('ImportForeignSchemaStmt');
@@ -7229,7 +7575,7 @@ class Deparser {
         if (node.relation) {
             output.push(this.RangeVar(node.relation, context));
             if (node.indexname) {
-                output.push('USING', `"${node.indexname}"`);
+                output.push('USING', quotes_1.QuoteUtils.quoteIdentifier(node.indexname));
             }
         }
         if (node.params && node.params.length > 0) {
@@ -7293,7 +7639,7 @@ class Deparser {
             output.push(this.RangeVar(node.relation, context));
         }
         if (node.name) {
-            output.push(`"${node.name}"`);
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
         }
         return output.join(' ');
     }
@@ -7333,7 +7679,7 @@ class Deparser {
         if (!node.dbname) {
             throw new Error('CreatedbStmt requires dbname');
         }
-        output.push(`"${node.dbname}"`);
+        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.dbname));
         if (node.options && node.options.length > 0) {
             const options = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, context))
@@ -7350,7 +7696,7 @@ class Deparser {
         if (!node.dbname) {
             throw new Error('DropdbStmt requires dbname');
         }
-        output.push(`"${node.dbname}"`);
+        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.dbname));
         if (node.options && node.options.length > 0) {
             const options = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, context))
@@ -7448,7 +7794,7 @@ class Deparser {
             case 'OBJECT_POLICY':
                 output.push('POLICY');
                 if (node.subname) {
-                    output.push(quote_utils_1.QuoteUtils.quote(node.subname));
+                    output.push(quotes_1.QuoteUtils.quoteIdentifier(node.subname));
                 }
                 break;
             case 'OBJECT_PUBLICATION':
@@ -7506,7 +7852,7 @@ class Deparser {
         }
         // Handle OBJECT_RULE special case: rule_name ON table_name format
         if (node.renameType === 'OBJECT_RULE' && node.subname && node.relation) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.subname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.subname));
             output.push('ON');
             output.push(this.RangeVar(node.relation, context));
         }
@@ -7525,12 +7871,21 @@ class Deparser {
                 if (items.length === 2) {
                     const accessMethod = items[0].String?.sval || '';
                     const objectName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(objectName)} USING ${accessMethod}`);
+                    output.push(`${quotes_1.QuoteUtils.quoteIdentifier(objectName)} USING ${accessMethod}`);
                 }
                 else {
                     output.push(this.visit(node.object, context));
                 }
             }
+            else if ((node.renameType === 'OBJECT_TYPE' || node.renameType === 'OBJECT_DOMAIN') && node.object.List) {
+                // Qualified type names - join List parts with dots
+                const items = list_utils_1.ListUtils.unwrapList(node.object);
+                const parts = items
+                    .map((item) => item.String?.sval)
+                    .filter((s) => typeof s === 'string')
+                    .map((s) => this.quoteIfNeeded(s));
+                output.push(parts.join('.'));
+            }
             else if (node.renameType === 'OBJECT_SCHEMA' && node.object.List) {
                 // Handle schema names - extract from List structure
                 const items = list_utils_1.ListUtils.unwrapList(node.object);
@@ -7546,19 +7901,19 @@ class Deparser {
             }
         }
         if (node.renameType === 'OBJECT_COLUMN' && node.subname) {
-            output.push('RENAME COLUMN', `"${node.subname}"`, 'TO');
+            output.push('RENAME COLUMN', quotes_1.QuoteUtils.quoteIdentifier(node.subname), 'TO');
         }
         else if (node.renameType === 'OBJECT_DOMCONSTRAINT' && node.subname) {
-            output.push('RENAME CONSTRAINT', `"${node.subname}"`, 'TO');
+            output.push('RENAME CONSTRAINT', quotes_1.QuoteUtils.quoteIdentifier(node.subname), 'TO');
         }
         else if (node.renameType === 'OBJECT_TABCONSTRAINT' && node.subname) {
-            output.push('RENAME CONSTRAINT', `"${node.subname}"`, 'TO');
+            output.push('RENAME CONSTRAINT', quotes_1.QuoteUtils.quoteIdentifier(node.subname), 'TO');
         }
         else if (node.renameType === 'OBJECT_ATTRIBUTE' && node.subname) {
-            output.push('RENAME ATTRIBUTE', `"${node.subname}"`, 'TO');
+            output.push('RENAME ATTRIBUTE', quotes_1.QuoteUtils.quoteIdentifier(node.subname), 'TO');
         }
         else if (node.renameType === 'OBJECT_ROLE' && node.subname) {
-            output.push(`"${node.subname}"`, 'RENAME TO');
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.subname), 'RENAME TO');
         }
         else if (node.renameType === 'OBJECT_SCHEMA' && node.subname) {
             output.push(this.quoteIfNeeded(node.subname), 'RENAME TO');
@@ -7572,7 +7927,7 @@ class Deparser {
         if (!node.newname) {
             throw new Error('RenameStmt requires newname');
         }
-        output.push(quote_utils_1.QuoteUtils.quote(node.newname));
+        output.push(quotes_1.QuoteUtils.quoteIdentifier(node.newname));
         // Handle CASCADE/RESTRICT behavior for RENAME operations
         if (node.behavior === 'DROP_CASCADE') {
             output.push('CASCADE');
@@ -7584,76 +7939,7 @@ class Deparser {
         if (!node.objectType) {
             throw new Error('AlterOwnerStmt requires objectType');
         }
-        switch (node.objectType) {
-            case 'OBJECT_TABLE':
-                output.push('TABLE');
-                break;
-            case 'OBJECT_VIEW':
-                output.push('VIEW');
-                break;
-            case 'OBJECT_INDEX':
-                output.push('INDEX');
-                break;
-            case 'OBJECT_SEQUENCE':
-                output.push('SEQUENCE');
-                break;
-            case 'OBJECT_FUNCTION':
-                output.push('FUNCTION');
-                break;
-            case 'OBJECT_PROCEDURE':
-                output.push('PROCEDURE');
-                break;
-            case 'OBJECT_SCHEMA':
-                output.push('SCHEMA');
-                break;
-            case 'OBJECT_DATABASE':
-                output.push('DATABASE');
-                break;
-            case 'OBJECT_DOMAIN':
-                output.push('DOMAIN');
-                break;
-            case 'OBJECT_AGGREGATE':
-                output.push('AGGREGATE');
-                break;
-            case 'OBJECT_CONVERSION':
-                output.push('CONVERSION');
-                break;
-            case 'OBJECT_LANGUAGE':
-                output.push('LANGUAGE');
-                break;
-            case 'OBJECT_OPERATOR':
-                output.push('OPERATOR');
-                break;
-            case 'OBJECT_OPFAMILY':
-                output.push('OPERATOR FAMILY');
-                break;
-            case 'OBJECT_OPCLASS':
-                output.push('OPERATOR CLASS');
-                break;
-            case 'OBJECT_TSDICTIONARY':
-                output.push('TEXT SEARCH DICTIONARY');
-                break;
-            case 'OBJECT_TSCONFIGURATION':
-                output.push('TEXT SEARCH CONFIGURATION');
-                break;
-            case 'OBJECT_EVENT_TRIGGER':
-                output.push('EVENT TRIGGER');
-                break;
-            case 'OBJECT_FDW':
-                output.push('FOREIGN DATA WRAPPER');
-                break;
-            case 'OBJECT_FOREIGN_SERVER':
-                output.push('SERVER');
-                break;
-            case 'OBJECT_TYPE':
-                output.push('TYPE');
-                break;
-            case 'OBJECT_COLLATION':
-                output.push('COLLATION');
-                break;
-            default:
-                throw new Error(`Unsupported AlterOwnerStmt objectType: ${node.objectType}`);
-        }
+        output.push(this.getObjectTypeKeyword(node.objectType));
         if (node.relation) {
             output.push(this.RangeVar(node.relation, context));
         }
@@ -7664,7 +7950,7 @@ class Deparser {
                 if (items.length === 2) {
                     const accessMethod = items[0].String?.sval || '';
                     const objectName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(objectName)} USING ${accessMethod}`);
+                    output.push(`${quotes_1.QuoteUtils.quoteIdentifier(objectName)} USING ${accessMethod}`);
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -7739,6 +8025,9 @@ class Deparser {
                 else if (node.objtype === 'OBJECT_LANGUAGE') {
                     output.push('LANGUAGE');
                 }
+                else if (node.objtype === 'OBJECT_SEQUENCE') {
+                    output.push('SEQUENCE');
+                }
                 else if (node.objtype === 'OBJECT_FUNCTION') {
                     output.push('FUNCTION');
                 }
@@ -7764,8 +8053,11 @@ class Deparser {
                     output.push('DATABASE');
                 }
                 if (node.objects && node.objects.length > 0) {
+                    const qualifiedKinds = ['OBJECT_TYPE', 'OBJECT_DOMAIN'];
                     const objects = list_utils_1.ListUtils.unwrapList(node.objects)
-                        .map(obj => this.visit(obj, context))
+                        .map(obj => qualifiedKinds.includes(node.objtype) && obj.List
+                        ? list_utils_1.ListUtils.unwrapList(obj.List.items).map((item) => this.visit(item, context)).join('.')
+                        : this.visit(obj, context))
                         .join(', ');
                     output.push(objects);
                 }
@@ -7804,8 +8096,11 @@ class Deparser {
                 break;
             default:
                 if (node.objects && node.objects.length > 0) {
+                    const qualifiedKinds = ['OBJECT_TYPE', 'OBJECT_DOMAIN'];
                     const objects = list_utils_1.ListUtils.unwrapList(node.objects)
-                        .map(obj => this.visit(obj, context))
+                        .map(obj => qualifiedKinds.includes(node.objtype) && obj.List
+                        ? list_utils_1.ListUtils.unwrapList(obj.List.items).map((item) => this.visit(item, context)).join('.')
+                        : this.visit(obj, context))
                         .join(', ');
                     output.push(objects);
                 }
@@ -7825,6 +8120,9 @@ class Deparser {
         if (node.grant_option && node.is_grant) {
             output.push('WITH GRANT OPTION');
         }
+        if (node.grantor) {
+            output.push('GRANTED BY', this.RoleSpec(node.grantor, context));
+        }
         // Only add behavior clauses for REVOKE statements, not for GRANT statements in ALTER DEFAULT PRIVILEGES
         if (!node.is_grant) {
             if (node.behavior === 'DROP_CASCADE') {
@@ -7838,57 +8136,34 @@ class Deparser {
     }
     GrantRoleStmt(node, context) {
         const output = [];
-        // Check for inherit, admin, and set options first to place them correctly
-        let hasInheritOption = false;
-        let hasAdminOption = false;
-        let hasSetOption = false;
-        let inheritValue;
-        let adminValue;
-        let setValue;
-        if (node.opt && node.opt.length > 0) {
-            const options = list_utils_1.ListUtils.unwrapList(node.opt);
-            const inheritOption = options.find(opt => opt.DefElem && opt.DefElem.defname === 'inherit');
-            const adminOption = options.find(opt => (opt.String && opt.String.sval === 'admin') ||
-                (opt.DefElem && opt.DefElem.defname === 'admin'));
-            const setOption = options.find(opt => opt.DefElem && opt.DefElem.defname === 'set');
-            if (inheritOption && inheritOption.DefElem) {
-                hasInheritOption = true;
-                inheritValue = inheritOption.DefElem.arg?.Boolean?.boolval;
-            }
-            if (adminOption) {
-                hasAdminOption = true;
-                if (adminOption.DefElem && adminOption.DefElem.arg) {
-                    adminValue = adminOption.DefElem.arg.Boolean?.boolval;
-                }
-            }
-            if (setOption && setOption.DefElem) {
-                hasSetOption = true;
-                setValue = setOption.DefElem.arg?.Boolean?.boolval;
-            }
-        }
+        const options = list_utils_1.ListUtils.unwrapList(node.opt)
+            .map(opt => opt.DefElem)
+            .filter((opt) => !!opt && !!opt.defname);
+        const optionValue = (opt) => {
+            if (!opt.arg)
+                return true;
+            const argType = this.getNodeType(opt.arg);
+            const argData = this.getNodeData(opt.arg);
+            if (argType === 'Boolean')
+                return argData.boolval !== false;
+            if (argType === 'String')
+                return argData.sval !== 'false';
+            return true;
+        };
+        const roles = list_utils_1.ListUtils.unwrapList(node.granted_roles)
+            .map(role => role.AccessPriv?.priv_name
+            ? quotes_1.QuoteUtils.quoteIdentifier(role.AccessPriv.priv_name)
+            : this.visit(role, context))
+            .join(', ');
         if (node.is_grant) {
-            output.push('GRANT');
+            output.push('GRANT', roles, 'TO');
         }
         else {
             output.push('REVOKE');
-            if (hasInheritOption) {
-                output.push('INHERIT OPTION FOR');
-            }
-            else if (hasAdminOption) {
-                output.push('ADMIN OPTION FOR');
+            if (options.length > 0) {
+                output.push(`${options[0].defname.toUpperCase()} OPTION FOR`);
             }
-        }
-        if (node.granted_roles && node.granted_roles.length > 0) {
-            const roles = list_utils_1.ListUtils.unwrapList(node.granted_roles)
-                .map(role => this.visit(role, context))
-                .join(', ');
-            output.push(roles);
-        }
-        if (node.is_grant) {
-            output.push('TO');
-        }
-        else {
-            output.push('FROM');
+            output.push(roles, 'FROM');
         }
         if (node.grantee_roles && node.grantee_roles.length > 0) {
             const grantees = list_utils_1.ListUtils.unwrapList(node.grantee_roles)
@@ -7896,45 +8171,22 @@ class Deparser {
                 .join(', ');
             output.push(grantees);
         }
-        if (node.is_grant) {
-            const withOptions = [];
-            if (hasAdminOption) {
-                if (adminValue === true) {
-                    withOptions.push('ADMIN OPTION');
-                }
-                else if (adminValue === false) {
-                    withOptions.push('ADMIN FALSE');
-                }
-                else {
-                    withOptions.push('ADMIN OPTION');
-                }
-            }
-            if (hasInheritOption) {
-                if (inheritValue === true) {
-                    withOptions.push('INHERIT OPTION');
-                }
-                else if (inheritValue === false) {
-                    withOptions.push('INHERIT FALSE');
-                }
-            }
-            if (hasSetOption) {
-                if (setValue === true) {
-                    withOptions.push('SET TRUE');
-                }
-                else if (setValue === false) {
-                    withOptions.push('SET FALSE');
-                }
-            }
-            if (withOptions.length > 0) {
-                output.push('WITH', withOptions.join(', '));
-            }
+        if (node.is_grant && options.length > 0) {
+            const withOptions = options.map(opt => `${opt.defname.toUpperCase()} ${optionValue(opt) ? 'TRUE' : 'FALSE'}`);
+            output.push('WITH', withOptions.join(', '));
+        }
+        if (node.grantor) {
+            output.push('GRANTED BY', this.RoleSpec(node.grantor, context));
+        }
+        if (!node.is_grant && node.behavior === 'DROP_CASCADE') {
+            output.push('CASCADE');
         }
         return output.join(' ');
     }
     SecLabelStmt(node, context) {
         const output = ['SECURITY LABEL'];
         if (node.provider) {
-            output.push('FOR', `"${node.provider}"`);
+            output.push('FOR', quotes_1.QuoteUtils.quoteIdentifier(node.provider));
         }
         output.push('ON');
         if (node.objtype) {
@@ -7962,11 +8214,21 @@ class Deparser {
             }
         }
         if (node.object) {
-            output.push(this.visit(node.object, context));
+            // Qualified names arrive as a List of String nodes and must be
+            // dot-joined (visiting the List directly would comma-join them).
+            if (typeof node.object === 'object' && 'List' in node.object) {
+                const list = node.object.List;
+                const objectParts = list_utils_1.ListUtils.unwrapList(list.items)
+                    .map(item => this.visit(item, context));
+                output.push(objectParts.join('.'));
+            }
+            else {
+                output.push(this.visit(node.object, context));
+            }
         }
         output.push('IS');
         if (node.label) {
-            output.push(`'${node.label}'`);
+            output.push(quotes_1.QuoteUtils.escape(node.label));
         }
         else {
             output.push('NULL');
@@ -8023,10 +8285,10 @@ class Deparser {
             output.push(conversionName);
         }
         if (node.for_encoding_name) {
-            output.push('FOR', `'${node.for_encoding_name}'`);
+            output.push('FOR', quotes_1.QuoteUtils.escape(node.for_encoding_name));
         }
         if (node.to_encoding_name) {
-            output.push('TO', `'${node.to_encoding_name}'`);
+            output.push('TO', quotes_1.QuoteUtils.escape(node.to_encoding_name));
         }
         if (node.func_name && node.func_name.length > 0) {
             output.push('FROM');
@@ -8087,7 +8349,7 @@ class Deparser {
         }
         output.push('LANGUAGE');
         if (node.plname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.plname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.plname));
         }
         if (node.plhandler && node.plhandler.length > 0) {
             output.push('HANDLER');
@@ -8123,7 +8385,7 @@ class Deparser {
         }
         output.push('LANGUAGE');
         if (node.lang) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.lang));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.lang));
         }
         output.push('(');
         const transforms = [];
@@ -8151,7 +8413,7 @@ class Deparser {
         }
         output.push('TRIGGER');
         if (node.trigname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.trigname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.trigname));
         }
         if (context.isPretty()) {
             const components = [];
@@ -8189,6 +8451,9 @@ class Deparser {
                     .join(' ');
                 components.push(context.indent('REFERENCING ' + transitionClauses));
             }
+            if (node.constrrel) {
+                components.push(context.indent('FROM ' + this.RangeVar(node.constrrel, context)));
+            }
             if (node.deferrable) {
                 components.push(context.indent('DEFERRABLE'));
             }
@@ -8210,7 +8475,7 @@ class Deparser {
                 const funcName = list_utils_1.ListUtils.unwrapList(node.funcname)
                     .map(name => this.visit(name, context))
                     .join('.');
-                executeStr += ' PROCEDURE ' + funcName;
+                executeStr += ' FUNCTION ' + funcName;
             }
             if (node.args && node.args.length > 0) {
                 const argContext = context.spawn('CreateTrigStmt', { isStringLiteral: true });
@@ -8315,14 +8580,14 @@ class Deparser {
             output.push('OLD TABLE AS');
         }
         if (node.name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
         }
         return output.join(' ');
     }
     CreateEventTrigStmt(node, context) {
         const output = ['CREATE EVENT TRIGGER'];
         if (node.trigname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.trigname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.trigname));
         }
         output.push('ON');
         if (node.eventname) {
@@ -8348,7 +8613,7 @@ class Deparser {
     AlterEventTrigStmt(node, context) {
         const output = ['ALTER EVENT TRIGGER'];
         if (node.trigname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.trigname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.trigname));
         }
         if (node.tgenabled) {
             switch (node.tgenabled) {
@@ -8468,6 +8733,74 @@ class Deparser {
                 .join(' ');
             output.push(whenClauses);
         }
+        if (node.returningClause) {
+            output.push(this.ReturningClause(node.returningClause, context));
+        }
+        return output.join(' ');
+    }
+    MergeSupportFunc(node, context) {
+        return 'merge_action()';
+    }
+    MergeWhenClause(node, context) {
+        const output = ['WHEN'];
+        switch (node.matchKind) {
+            case 'MERGE_WHEN_MATCHED':
+                output.push('MATCHED');
+                break;
+            case 'MERGE_WHEN_NOT_MATCHED_BY_SOURCE':
+                output.push('NOT MATCHED BY SOURCE');
+                break;
+            case 'MERGE_WHEN_NOT_MATCHED_BY_TARGET':
+                output.push('NOT MATCHED');
+                break;
+        }
+        if (node.condition) {
+            output.push('AND');
+            output.push(this.visit(node.condition, context));
+        }
+        output.push('THEN');
+        switch (node.commandType) {
+            case 'CMD_UPDATE': {
+                output.push('UPDATE SET');
+                if (node.targetList && node.targetList.length > 0) {
+                    output.push(this.formatUpdateAssignments(node.targetList, context));
+                }
+                break;
+            }
+            case 'CMD_INSERT': {
+                output.push('INSERT');
+                const targetList = list_utils_1.ListUtils.unwrapList(node.targetList);
+                if (targetList.length > 0) {
+                    const columns = targetList
+                        .map(target => quotes_1.QuoteUtils.quoteIdentifier(target.ResTarget?.name))
+                        .join(', ');
+                    output.push(`(${columns})`);
+                }
+                if (node.override === 'OVERRIDING_USER_VALUE') {
+                    output.push('OVERRIDING USER VALUE');
+                }
+                else if (node.override === 'OVERRIDING_SYSTEM_VALUE') {
+                    output.push('OVERRIDING SYSTEM VALUE');
+                }
+                const values = list_utils_1.ListUtils.unwrapList(node.values);
+                if (values.length > 0) {
+                    const valueItems = values
+                        .map(value => this.visit(value, context))
+                        .join(', ');
+                    output.push(`VALUES (${valueItems})`);
+                }
+                else {
+                    output.push('DEFAULT VALUES');
+                }
+                break;
+            }
+            case 'CMD_DELETE':
+                output.push('DELETE');
+                break;
+            case 'CMD_NOTHING':
+                output.push('DO NOTHING');
+                break;
+        }
         return output.join(' ');
     }
     AlterTableMoveAllStmt(node, context) {
@@ -8483,11 +8816,11 @@ class Deparser {
         }
         output.push('ALL', 'IN', 'TABLESPACE');
         if (node.orig_tablespacename) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.orig_tablespacename));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.orig_tablespacename));
         }
         output.push('SET', 'TABLESPACE');
         if (node.new_tablespacename) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.new_tablespacename));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.new_tablespacename));
         }
         if (node.nowait) {
             output.push('NOWAIT');
@@ -8511,10 +8844,10 @@ class Deparser {
             const sequenceName = [];
             const seq = node.sequence;
             if (seq.schemaname) {
-                sequenceName.push(quote_utils_1.QuoteUtils.quote(seq.schemaname));
+                sequenceName.push(quotes_1.QuoteUtils.quoteIdentifier(seq.schemaname));
             }
             if (seq.relname) {
-                sequenceName.push(quote_utils_1.QuoteUtils.quote(seq.relname));
+                sequenceName.push(quotes_1.QuoteUtils.quoteIdentifier(seq.relname));
             }
             output.push(sequenceName.join('.'));
         }
@@ -8548,10 +8881,10 @@ class Deparser {
             const sequenceName = [];
             const seq = node.sequence;
             if (seq.schemaname) {
-                sequenceName.push(quote_utils_1.QuoteUtils.quote(seq.schemaname));
+                sequenceName.push(quotes_1.QuoteUtils.quoteIdentifier(seq.schemaname));
             }
             if (seq.relname) {
-                sequenceName.push(quote_utils_1.QuoteUtils.quote(seq.relname));
+                sequenceName.push(quotes_1.QuoteUtils.quoteIdentifier(seq.relname));
             }
             output.push(sequenceName.join('.'));
         }
@@ -8836,6 +9169,13 @@ class Deparser {
             output.push('USING');
             output.push(node.into.accessMethod);
         }
+        if (node.into && node.into.options && node.into.options.length > 0) {
+            output.push('WITH');
+            const options = list_utils_1.ListUtils.unwrapList(node.into.options)
+                .map(option => this.visit(option, context.spawn('CreateStmt')))
+                .join(', ');
+            output.push(`(${options})`);
+        }
         if (node.into && node.into.onCommit && node.into.onCommit !== 'ONCOMMIT_NOOP') {
             output.push('ON COMMIT');
             switch (node.into.onCommit) {
@@ -8850,17 +9190,13 @@ class Deparser {
                     break;
             }
         }
+        if (node.into && node.into.tableSpaceName) {
+            output.push('TABLESPACE', quotes_1.QuoteUtils.quoteIdentifier(node.into.tableSpaceName));
+        }
         output.push('AS');
         if (node.query) {
             output.push(this.visit(node.query, context));
         }
-        if (node.into && node.into.options && node.into.options.length > 0) {
-            output.push('WITH');
-            const options = list_utils_1.ListUtils.unwrapList(node.into.options)
-                .map(option => this.visit(option, context))
-                .join(', ');
-            output.push(`(${options})`);
-        }
         if (node.into && node.into.skipData) {
             output.push('WITH NO DATA');
         }
@@ -8898,7 +9234,7 @@ class Deparser {
     }
     aliasname(node, context) {
         if (typeof node === 'string') {
-            return quote_utils_1.QuoteUtils.quote(node);
+            return quotes_1.QuoteUtils.quoteIdentifier(node);
         }
         return this.visit(node, context);
     }
@@ -8930,18 +9266,16 @@ class Deparser {
                             const defName = defElem.defname;
                             const defValue = defElem.arg;
                             if (defName && defValue) {
-                                let preservedDefName;
-                                if (Deparser.needsQuotes(defName)) {
-                                    preservedDefName = `"${defName}"`;
-                                }
-                                else {
-                                    preservedDefName = this.preserveOperatorDefElemCase(defName);
-                                }
+                                const quotedDefName = quotes_1.QuoteUtils.quoteIdentifier(defName);
+                                const preservedDefName = quotedDefName !== defName ? quotedDefName : this.preserveOperatorDefElemCase(defName);
                                 if ((defName.toLowerCase() === 'commutator' || defName.toLowerCase() === 'negator') && defValue.List) {
                                     const listItems = list_utils_1.ListUtils.unwrapList(defValue.List.items);
                                     if (listItems.length === 1 && listItems[0].String) {
                                         return `${preservedDefName} = ${listItems[0].String.sval}`;
                                     }
+                                    if (listItems.length > 1 && listItems.every(item => item.String)) {
+                                        return `${preservedDefName} = OPERATOR(${this.qualifiedOperatorName(listItems)})`;
+                                    }
                                 }
                                 // For commutator/negator, we already handled them above
                                 if ((defName.toLowerCase() === 'commutator' || defName.toLowerCase() === 'negator')) {
@@ -8952,7 +9286,7 @@ class Deparser {
                             else if (defName && !defValue) {
                                 // Handle boolean flags like HASHES, MERGES - preserve original case
                                 if (defName === 'Hashes' || defName === 'Merges') {
-                                    return `"${defName}"`;
+                                    return quotes_1.QuoteUtils.quoteIdentifier(defName);
                                 }
                                 return this.preserveOperatorDefElemCase(defName).toUpperCase();
                             }
@@ -9091,16 +9425,11 @@ class Deparser {
                             const defName = defElem.defname;
                             const defValue = defElem.arg;
                             if (defName && defValue) {
-                                let preservedDefName;
-                                if (Deparser.needsQuotes(defName)) {
-                                    preservedDefName = `"${defName}"`;
-                                }
-                                else {
-                                    preservedDefName = defName;
-                                }
+                                const quotedDefName = quotes_1.QuoteUtils.quoteIdentifier(defName);
+                                const preservedDefName = quotedDefName !== defName ? quotedDefName : defName;
                                 // Handle String arguments with single quotes for string literals
                                 if (defValue.String) {
-                                    return `${preservedDefName} = '${defValue.String.sval}'`;
+                                    return `${preservedDefName} = ${quotes_1.QuoteUtils.escape(defValue.String.sval)}`;
                                 }
                                 return `${preservedDefName} = ${this.visit(defValue, context)}`;
                             }
@@ -9223,7 +9552,7 @@ class Deparser {
                                 // For CREATE COLLATION, ensure String nodes are quoted as string literals
                                 let valueStr;
                                 if (defValue.String) {
-                                    valueStr = `'${defValue.String.sval}'`;
+                                    valueStr = quotes_1.QuoteUtils.escape(defValue.String.sval);
                                 }
                                 else {
                                     valueStr = this.visit(defValue, context);
@@ -9252,7 +9581,7 @@ class Deparser {
     AlterDatabaseStmt(node, context) {
         const output = ['ALTER', 'DATABASE'];
         if (node.dbname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.dbname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.dbname));
         }
         if (node.options && node.options.length > 0) {
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, context));
@@ -9263,7 +9592,7 @@ class Deparser {
     AlterDatabaseRefreshCollStmt(node, context) {
         const output = ['ALTER', 'DATABASE'];
         if (node.dbname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.dbname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.dbname));
         }
         output.push('REFRESH', 'COLLATION', 'VERSION');
         return output.join(' ');
@@ -9271,7 +9600,7 @@ class Deparser {
     AlterDatabaseSetStmt(node, context) {
         const output = ['ALTER', 'DATABASE'];
         if (node.dbname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.dbname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.dbname));
         }
         if (node.setstmt) {
             const setClause = this.VariableSetStmt(node.setstmt, context);
@@ -9282,7 +9611,7 @@ class Deparser {
     DeclareCursorStmt(node, context) {
         const output = ['DECLARE'];
         if (node.portalname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.portalname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.portalname));
         }
         // Handle cursor options before CURSOR keyword
         const cursorOptions = [];
@@ -9324,7 +9653,7 @@ class Deparser {
         else if (node.pubobjtype === 'PUBLICATIONOBJ_TABLES_IN_SCHEMA') {
             output.push('TABLES IN SCHEMA');
             if (node.name) {
-                output.push(quote_utils_1.QuoteUtils.quote(node.name));
+                output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
             }
         }
         else if (node.pubobjtype === 'PUBLICATIONOBJ_TABLES_IN_CUR_SCHEMA') {
@@ -9343,14 +9672,14 @@ class Deparser {
         }
         if (node.whereClause) {
             output.push('WHERE');
-            output.push(this.visit(node.whereClause, context));
+            output.push(`(${this.visit(node.whereClause, context)})`);
         }
         return output.join(' ');
     }
     CreateAmStmt(node, context) {
         const output = ['CREATE', 'ACCESS', 'METHOD'];
         if (node.amname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.amname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.amname));
         }
         output.push('TYPE');
         switch (node.amtype) {
@@ -9410,7 +9739,7 @@ class Deparser {
             }
         }
         if (node.tableSpaceName) {
-            output.push('TABLESPACE', quote_utils_1.QuoteUtils.quote(node.tableSpaceName));
+            output.push('TABLESPACE', quotes_1.QuoteUtils.quoteIdentifier(node.tableSpaceName));
         }
         return output.join(' ');
     }
@@ -9490,6 +9819,23 @@ class Deparser {
         }
         return output.join(' ');
     }
+    quoteDefElemArg(arg, argValue) {
+        if (arg && this.getNodeType(arg) === 'String') {
+            return quotes_1.QuoteUtils.escape(this.getNodeData(arg).sval || '');
+        }
+        return typeof argValue === 'string' && !argValue.startsWith("'")
+            ? quotes_1.QuoteUtils.escape(argValue)
+            : argValue;
+    }
+    formatOptionValue(arg, argValue) {
+        if (arg && this.getNodeType(arg) === 'String') {
+            const sval = this.getNodeData(arg).sval || '';
+            return /^[a-z_][a-z0-9_]*$/.test(sval) && (0, quotes_1.keywordKindOf)(sval) === 'NO_KEYWORD'
+                ? sval
+                : quotes_1.QuoteUtils.escape(sval);
+        }
+        return argValue;
+    }
     Var(node, context) {
         if (node.varno && node.varattno) {
             return `$${node.varno}.${node.varattno}`;
@@ -9529,7 +9875,7 @@ class Deparser {
             }
             if (node.rowexpr) {
                 output.push(',');
-                output.push(`'${this.visit(node.rowexpr, context)}'`);
+                output.push(this.visit(node.rowexpr, context));
             }
             if (node.colexprs && node.colexprs.length > 0) {
                 output.push('COLUMNS');
@@ -9546,29 +9892,44 @@ class Deparser {
         if (node.lateral) {
             output.push('LATERAL');
         }
-        if (node.docexpr) {
-            output.push(this.visit(node.docexpr, context));
+        const args = [];
+        if (node.namespaces && node.namespaces.length > 0) {
+            const namespaces = list_utils_1.ListUtils.unwrapList(node.namespaces).map(ns => {
+                const target = this.getNodeData(ns);
+                const uri = this.visit(target.val, context);
+                return target.name ? `${uri} AS ${quotes_1.QuoteUtils.quoteIdentifier(target.name)}` : `DEFAULT ${uri}`;
+            });
+            args.push(`XMLNAMESPACES(${namespaces.join(', ')}),`);
         }
         if (node.rowexpr) {
-            output.push('PASSING');
-            output.push(this.visit(node.rowexpr, context));
+            args.push(this.formatXmlTableExpr(node.rowexpr, context));
+        }
+        if (node.docexpr) {
+            args.push('PASSING');
+            args.push(this.formatXmlTableExpr(node.docexpr, context));
         }
         if (node.columns && node.columns.length > 0) {
-            output.push('COLUMNS');
-            const columns = list_utils_1.ListUtils.unwrapList(node.columns)
+            args.push('COLUMNS');
+            args.push(list_utils_1.ListUtils.unwrapList(node.columns)
                 .map(col => this.visit(col, context))
-                .join(', ');
-            output.push(`(${columns})`);
+                .join(', '));
         }
+        output.push(`XMLTABLE(${args.join(' ')})`);
         if (node.alias) {
             output.push(this.Alias(node.alias, context));
         }
         return output.join(' ');
     }
+    formatXmlTableExpr(expr, context) {
+        const value = this.visit(expr, context);
+        return ['A_Const', 'ColumnRef', 'ParamRef', 'FuncCall'].includes(this.getNodeType(expr))
+            ? value
+            : `(${value})`;
+    }
     RangeTableFuncCol(node, context) {
         const output = [];
         if (node.colname) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.colname));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.colname));
         }
         if (node.for_ordinality) {
             output.push('FOR ORDINALITY');
@@ -9578,32 +9939,193 @@ class Deparser {
         }
         if (node.colexpr) {
             output.push('PATH');
-            output.push(`'${this.visit(node.colexpr, context)}'`);
+            output.push(this.visit(node.colexpr, context));
         }
         if (node.coldefexpr) {
             output.push('DEFAULT');
             output.push(this.visit(node.coldefexpr, context));
         }
+        if (node.is_not_null) {
+            output.push('NOT NULL');
+        }
         return output.join(' ');
     }
+    formatJsonFormat(format) {
+        if (!format || !format.format_type || format.format_type === 'JS_FORMAT_DEFAULT') {
+            return null;
+        }
+        const parts = ['FORMAT JSON'];
+        switch (format.encoding) {
+            case 'JS_ENC_UTF8':
+                parts.push('ENCODING UTF8');
+                break;
+            case 'JS_ENC_UTF16':
+                parts.push('ENCODING UTF16');
+                break;
+            case 'JS_ENC_UTF32':
+                parts.push('ENCODING UTF32');
+                break;
+        }
+        return parts.join(' ');
+    }
+    formatJsonOutput(output, context) {
+        if (!output || !output.typeName)
+            return null;
+        const parts = ['RETURNING', this.TypeName(output.typeName, context)];
+        const format = this.formatJsonFormat(output.returning?.format);
+        if (format)
+            parts.push(format);
+        return parts.join(' ');
+    }
+    formatJsonNullClause(absentOnNull) {
+        return absentOnNull ? 'ABSENT ON NULL' : 'NULL ON NULL';
+    }
+    formatJsonUniqueClause(unique) {
+        return unique ? 'WITH UNIQUE KEYS' : null;
+    }
+    JsonValueExpr(node, context) {
+        const parts = [];
+        if (node.raw_expr) {
+            parts.push(this.visit(node.raw_expr, context));
+        }
+        const format = this.formatJsonFormat(node.format);
+        if (format)
+            parts.push(format);
+        return parts.join(' ');
+    }
+    JsonKeyValue(node, context) {
+        const key = node.key ? this.visit(node.key, context) : '';
+        const value = node.value ? this.JsonValueExpr(node.value, context) : '';
+        return `${key} : ${value}`;
+    }
+    JsonObjectConstructor(node, context) {
+        const args = [];
+        if (node.exprs && node.exprs.length > 0) {
+            args.push(list_utils_1.ListUtils.unwrapList(node.exprs).map(e => this.visit(e, context)).join(', '));
+            args.push(this.formatJsonNullClause(node.absent_on_null));
+            const unique = this.formatJsonUniqueClause(node.unique);
+            if (unique)
+                args.push(unique);
+        }
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_OBJECT(${args.join(' ')})`;
+    }
+    JsonArrayConstructor(node, context) {
+        const args = [];
+        if (node.exprs && node.exprs.length > 0) {
+            args.push(list_utils_1.ListUtils.unwrapList(node.exprs).map(e => this.visit(e, context)).join(', '));
+            args.push(this.formatJsonNullClause(node.absent_on_null));
+        }
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_ARRAY(${args.join(' ')})`;
+    }
     JsonArrayQueryConstructor(node, context) {
-        const output = ['JSON_ARRAYAGG'];
+        const args = [];
         if (node.query) {
-            output.push(`(${this.visit(node.query, context)})`);
+            args.push(this.visit(node.query, context));
+        }
+        const format = this.formatJsonFormat(node.format);
+        if (format)
+            args.push(format);
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_ARRAY(${args.join(' ')})`;
+    }
+    formatJsonAggSuffix(ctor, context) {
+        if (!ctor)
+            return '';
+        let result = '';
+        if (ctor.agg_filter) {
+            result += ` FILTER (WHERE ${this.visit(ctor.agg_filter, context)})`;
         }
-        if (node.format) {
-            output.push('FORMAT JSON');
+        if (ctor.over) {
+            result += this.formatOverClause(ctor.over, context);
         }
-        if (node.output) {
-            output.push('RETURNING TEXT');
+        return result;
+    }
+    JsonObjectAgg(node, context) {
+        const args = [];
+        if (node.arg) {
+            args.push(this.JsonKeyValue(node.arg, context));
+        }
+        args.push(this.formatJsonNullClause(node.absent_on_null));
+        const unique = this.formatJsonUniqueClause(node.unique);
+        if (unique)
+            args.push(unique);
+        const output = this.formatJsonOutput(node.constructor?.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_OBJECTAGG(${args.join(' ')})${this.formatJsonAggSuffix(node.constructor, context)}`;
+    }
+    JsonArrayAgg(node, context) {
+        const args = [];
+        if (node.arg) {
+            args.push(this.JsonValueExpr(node.arg, context));
         }
-        if (node.absent_on_null) {
-            output.push('ABSENT ON NULL');
+        const aggOrder = node.constructor?.agg_order;
+        if (aggOrder && aggOrder.length > 0) {
+            const orderItems = list_utils_1.ListUtils.unwrapList(aggOrder).map(item => this.visit(item, context));
+            args.push(`ORDER BY ${orderItems.join(', ')}`);
         }
-        else {
-            output.push('NULL ON NULL');
+        args.push(this.formatJsonNullClause(node.absent_on_null));
+        const output = this.formatJsonOutput(node.constructor?.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_ARRAYAGG(${args.join(' ')})${this.formatJsonAggSuffix(node.constructor, context)}`;
+    }
+    JsonParseExpr(node, context) {
+        const args = [];
+        if (node.expr) {
+            args.push(this.JsonValueExpr(node.expr, context));
         }
-        return output.join(' ');
+        const unique = this.formatJsonUniqueClause(node.unique_keys);
+        if (unique)
+            args.push(unique);
+        return `JSON(${args.join(' ')})`;
+    }
+    JsonScalarExpr(node, context) {
+        const expr = node.expr ? this.visit(node.expr, context) : '';
+        return `JSON_SCALAR(${expr})`;
+    }
+    JsonSerializeExpr(node, context) {
+        const args = [];
+        if (node.expr) {
+            args.push(this.JsonValueExpr(node.expr, context));
+        }
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_SERIALIZE(${args.join(' ')})`;
+    }
+    JsonIsPredicate(node, context) {
+        const parts = [];
+        if (node.expr) {
+            parts.push(this.visit(node.expr, context));
+        }
+        const format = this.formatJsonFormat(node.format);
+        if (format)
+            parts.push(format);
+        parts.push('IS JSON');
+        switch (node.item_type) {
+            case 'JS_TYPE_OBJECT':
+                parts.push('OBJECT');
+                break;
+            case 'JS_TYPE_ARRAY':
+                parts.push('ARRAY');
+                break;
+            case 'JS_TYPE_SCALAR':
+                parts.push('SCALAR');
+                break;
+        }
+        if (node.unique_keys) {
+            parts.push('WITH UNIQUE KEYS');
+        }
+        return parts.join(' ');
     }
     RangeFunction(node, context) {
         const output = [];
@@ -9714,10 +10236,10 @@ class Deparser {
         if (node.op === 'IS_XMLPI') {
             if (node.name && node.args && node.args.length > 0) {
                 const argStrs = list_utils_1.ListUtils.unwrapList(node.args).map(arg => this.visit(arg, context));
-                return `xmlpi(name ${quote_utils_1.QuoteUtils.quote(node.name)}, ${argStrs.join(', ')})`;
+                return `xmlpi(name ${quotes_1.QuoteUtils.quoteIdentifier(node.name)}, ${argStrs.join(', ')})`;
             }
             else if (node.name) {
-                return `xmlpi(name ${quote_utils_1.QuoteUtils.quote(node.name)})`;
+                return `xmlpi(name ${quotes_1.QuoteUtils.quoteIdentifier(node.name)})`;
             }
             else {
                 return 'XMLPI()';
@@ -9732,7 +10254,7 @@ class Deparser {
                 output.push('XMLELEMENT');
                 const elementParts = [];
                 if (node.name) {
-                    elementParts.push(`NAME ${quote_utils_1.QuoteUtils.quote(node.name)}`);
+                    elementParts.push(`NAME ${quotes_1.QuoteUtils.quoteIdentifier(node.name)}`);
                 }
                 if (node.named_args && node.named_args.length > 0) {
                     const namedArgStrs = list_utils_1.ListUtils.unwrapList(node.named_args).map(arg => this.visit(arg, context));
@@ -9797,6 +10319,7 @@ class Deparser {
                                 rootParts.push('STANDALONE NO VALUE');
                             }
                             else if (standaloneArg.A_Const.ival.ival === 3) {
+                                // STANDALONE omitted
                             }
                             else if (Object.keys(standaloneArg.A_Const.ival).length === 0) {
                                 rootParts.push('STANDALONE YES');
@@ -9832,7 +10355,7 @@ class Deparser {
         // Handle name and args for operations that don't have special handling
         if (node.op !== 'IS_XMLELEMENT' && node.op !== 'IS_XMLPARSE' && node.op !== 'IS_XMLROOT' && node.op !== 'IS_DOCUMENT') {
             if (node.name) {
-                const quotedName = quote_utils_1.QuoteUtils.quote(node.name);
+                const quotedName = quotes_1.QuoteUtils.quoteIdentifier(node.name);
                 output.push(`NAME ${quotedName}`);
             }
             if (node.args && node.args.length > 0) {
@@ -9853,26 +10376,26 @@ class Deparser {
     }
     schemaname(node, context) {
         if (typeof node === 'string') {
-            return quote_utils_1.QuoteUtils.quote(node);
+            return quotes_1.QuoteUtils.quoteIdentifier(node);
         }
         if (node && node.String && node.String.sval) {
-            return quote_utils_1.QuoteUtils.quote(node.String.sval);
+            return quotes_1.QuoteUtils.quoteIdentifier(node.String.sval);
         }
         // Handle other node types without recursion
         if (node && typeof node === 'object') {
             if (node.sval !== undefined) {
-                return quote_utils_1.QuoteUtils.quote(node.sval);
+                return quotes_1.QuoteUtils.quoteIdentifier(node.sval);
             }
             // Handle List nodes that might contain schema names
             if (node.List && Array.isArray(node.List.items)) {
                 const items = node.List.items;
                 if (items.length > 0 && items[0].String && items[0].String.sval) {
-                    return quote_utils_1.QuoteUtils.quote(items[0].String.sval);
+                    return quotes_1.QuoteUtils.quoteIdentifier(items[0].String.sval);
                 }
             }
             // For other complex nodes, try to extract string value without recursion
             if (node.val !== undefined) {
-                return quote_utils_1.QuoteUtils.quote(node.val);
+                return quotes_1.QuoteUtils.quoteIdentifier(node.val);
             }
             return '';
         }
@@ -9935,7 +10458,7 @@ class Deparser {
         }
         output.push('RULE');
         if (node.rulename) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.rulename));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.rulename));
         }
         output.push('AS ON');
         if (node.event) {
@@ -10002,42 +10525,42 @@ class Deparser {
     }
     relname(node, context) {
         if (typeof node === 'string') {
-            return quote_utils_1.QuoteUtils.quote(node);
+            return quotes_1.QuoteUtils.quoteIdentifier(node);
         }
         if (node && node.String && node.String.sval) {
-            return quote_utils_1.QuoteUtils.quote(node.String.sval);
+            return quotes_1.QuoteUtils.quoteIdentifier(node.String.sval);
         }
         if (node && typeof node === 'object' && node.relname) {
-            return quote_utils_1.QuoteUtils.quote(node.relname);
+            return quotes_1.QuoteUtils.quoteIdentifier(node.relname);
         }
         return this.visit(node, context);
     }
     rel(node, context) {
         if (typeof node === 'string') {
-            return quote_utils_1.QuoteUtils.quote(node);
+            return quotes_1.QuoteUtils.quoteIdentifier(node);
         }
         if (node && node.String && node.String.sval) {
-            return quote_utils_1.QuoteUtils.quote(node.String.sval);
+            return quotes_1.QuoteUtils.quoteIdentifier(node.String.sval);
         }
         if (node && node.RangeVar) {
             return this.RangeVar(node.RangeVar, context);
         }
         if (node && typeof node === 'object' && node.relname) {
-            return quote_utils_1.QuoteUtils.quote(node.relname);
+            return quotes_1.QuoteUtils.quoteIdentifier(node.relname);
         }
         return this.visit(node, context);
     }
     objname(node, context) {
         if (typeof node === 'string') {
-            return quote_utils_1.QuoteUtils.quote(node);
+            return quotes_1.QuoteUtils.quoteIdentifier(node);
         }
         if (node && node.String && node.String.sval) {
-            return quote_utils_1.QuoteUtils.quote(node.String.sval);
+            return quotes_1.QuoteUtils.quoteIdentifier(node.String.sval);
         }
         if (Array.isArray(node)) {
             const parts = node.map(part => {
                 if (part && part.String && part.String.sval) {
-                    return quote_utils_1.QuoteUtils.quote(part.String.sval);
+                    return quotes_1.QuoteUtils.quoteIdentifier(part.String.sval);
                 }
                 return this.visit(part, context);
             });
@@ -10108,7 +10631,7 @@ class Deparser {
     CurrentOfExpr(node, context) {
         const output = ['CURRENT OF'];
         if (node.cursor_name) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.cursor_name));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.cursor_name));
         }
         if (node.cursor_param > 0) {
             output.push(`$${node.cursor_param}`);
@@ -10171,66 +10694,12 @@ class Deparser {
     }
     AlterObjectSchemaStmt(node, context) {
         const output = ['ALTER'];
-        switch (node.objectType) {
-            case 'OBJECT_TABLE':
-                output.push('TABLE');
-                break;
-            case 'OBJECT_VIEW':
-                output.push('VIEW');
-                break;
-            case 'OBJECT_FUNCTION':
-                output.push('FUNCTION');
-                break;
-            case 'OBJECT_TYPE':
-                output.push('TYPE');
-                break;
-            case 'OBJECT_DOMAIN':
-                output.push('DOMAIN');
-                break;
-            case 'OBJECT_SEQUENCE':
-                output.push('SEQUENCE');
-                break;
-            case 'OBJECT_OPCLASS':
-                output.push('OPERATOR CLASS');
-                break;
-            case 'OBJECT_OPFAMILY':
-                output.push('OPERATOR FAMILY');
-                break;
-            case 'OBJECT_OPERATOR':
-                output.push('OPERATOR');
-                break;
-            case 'OBJECT_TYPE':
-                output.push('TYPE');
-                break;
-            case 'OBJECT_COLLATION':
-                output.push('COLLATION');
-                break;
-            case 'OBJECT_CONVERSION':
-                output.push('CONVERSION');
-                break;
-            case 'OBJECT_TSPARSER':
-                output.push('TEXT SEARCH PARSER');
-                break;
-            case 'OBJECT_TSCONFIGURATION':
-                output.push('TEXT SEARCH CONFIGURATION');
-                break;
-            case 'OBJECT_TSTEMPLATE':
-                output.push('TEXT SEARCH TEMPLATE');
-                break;
-            case 'OBJECT_TSDICTIONARY':
-                output.push('TEXT SEARCH DICTIONARY');
-                break;
-            case 'OBJECT_AGGREGATE':
-                output.push('AGGREGATE');
-                break;
-            case 'OBJECT_FOREIGN_TABLE':
-                output.push('FOREIGN TABLE');
-                break;
-            case 'OBJECT_MATVIEW':
-                output.push('MATERIALIZED VIEW');
-                break;
-            default:
-                output.push(node.objectType.toString());
+        try {
+            output.push(this.getObjectTypeKeyword(node.objectType));
+        }
+        catch {
+            // Fallback to objectType string if not supported
+            output.push(node.objectType.toString());
         }
         if (node.missing_ok) {
             output.push('IF EXISTS');
@@ -10245,7 +10714,7 @@ class Deparser {
                 if (items.length === 2) {
                     const schemaName = items[0].String?.sval || '';
                     const domainName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(domainName)}`);
+                    output.push(quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, domainName));
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10257,7 +10726,7 @@ class Deparser {
                 if (items.length === 2) {
                     const schemaName = items[0].String?.sval || '';
                     const typeName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(typeName)}`);
+                    output.push(quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, typeName));
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10269,7 +10738,7 @@ class Deparser {
                 if (items.length === 2) {
                     const schemaName = items[0].String?.sval || '';
                     const conversionName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(conversionName)}`);
+                    output.push(quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, conversionName));
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10281,7 +10750,7 @@ class Deparser {
                 if (items.length === 2) {
                     const schemaName = items[0].String?.sval || '';
                     const parserName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(parserName)}`);
+                    output.push(quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, parserName));
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10293,7 +10762,7 @@ class Deparser {
                 if (items.length === 2) {
                     const schemaName = items[0].String?.sval || '';
                     const configName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(configName)}`);
+                    output.push(quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, configName));
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10305,7 +10774,7 @@ class Deparser {
                 if (items.length === 2) {
                     const schemaName = items[0].String?.sval || '';
                     const templateName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(templateName)}`);
+                    output.push(quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, templateName));
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10317,7 +10786,7 @@ class Deparser {
                 if (items.length === 2) {
                     const schemaName = items[0].String?.sval || '';
                     const dictionaryName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(dictionaryName)}`);
+                    output.push(quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, dictionaryName));
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10329,13 +10798,13 @@ class Deparser {
                 if (items.length === 2) {
                     const accessMethod = items[0].String?.sval || '';
                     const opClassName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(opClassName)} USING ${accessMethod}`);
+                    output.push(`${quotes_1.QuoteUtils.quoteIdentifier(opClassName)} USING ${accessMethod}`);
                 }
                 else if (items.length === 3) {
                     const accessMethod = items[0].String?.sval || '';
                     const schemaName = items[1].String?.sval || '';
                     const opClassName = items[2].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(opClassName)} USING ${accessMethod}`);
+                    output.push(`${quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, opClassName)} USING ${accessMethod}`);
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10347,13 +10816,13 @@ class Deparser {
                 if (items.length === 2) {
                     const accessMethod = items[0].String?.sval || '';
                     const opFamilyName = items[1].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(opFamilyName)} USING ${accessMethod}`);
+                    output.push(`${quotes_1.QuoteUtils.quoteIdentifier(opFamilyName)} USING ${accessMethod}`);
                 }
                 else if (items.length === 3) {
                     const accessMethod = items[0].String?.sval || '';
                     const schemaName = items[1].String?.sval || '';
                     const opFamilyName = items[2].String?.sval || '';
-                    output.push(`${quote_utils_1.QuoteUtils.quote(schemaName)}.${quote_utils_1.QuoteUtils.quote(opFamilyName)} USING ${accessMethod}`);
+                    output.push(`${quotes_1.QuoteUtils.quoteQualifiedIdentifier(schemaName, opFamilyName)} USING ${accessMethod}`);
                 }
                 else {
                     output.push(this.visit(node.object, context));
@@ -10365,7 +10834,7 @@ class Deparser {
         }
         output.push('SET SCHEMA');
         if (node.newschema) {
-            output.push(quote_utils_1.QuoteUtils.quote(node.newschema));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.newschema));
         }
         return output.join(' ');
     }
@@ -10434,7 +10903,7 @@ class Deparser {
         }
         if (node.servername) {
             output.push('SERVER');
-            output.push(quote_utils_1.QuoteUtils.quote(node.servername));
+            output.push(quotes_1.QuoteUtils.quoteIdentifier(node.servername));
         }
         if (node.options && node.options.length > 0) {
             const foreignTableContext = context.spawn('CreateForeignTableStmt');
@@ -10443,9 +10912,5 @@ class Deparser {
         }
         return output.join(' ');
     }
-    containsMultilineStringLiteral(content) {
-        const stringLiteralRegex = /'[^']*\n[^']*'/g;
-        return stringLiteralRegex.test(content);
-    }
 }
 exports.Deparser = Deparser;