pgsql-deparser 17.8.1 → 17.8.3

package/deparser.js

@@ -1,9 +1,66 @@
 "use strict";
 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 list_utils_1 = require("./utils/list-utils");
+/**
+ * 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.
+ * Use these for lookups, validations, or introspection logic.
+ */
+const pgCatalogTypes = [
+    // Integers
+    'int2', // smallint
+    'int4', // integer
+    'int8', // bigint
+    // Floating-point & numeric
+    'float4', // real
+    'float8', // double precision
+    'numeric', // arbitrary precision (aka "decimal")
+    // Text & string
+    'varchar', // variable-length string
+    'char', // internal one-byte type (used in special cases)
+    'bpchar', // blank-padded char(n)
+    'text', // unlimited string
+    'bool', // boolean
+    // Dates & times
+    'date', // calendar date
+    'time', // time without time zone
+    'timetz', // time with time zone
+    'timestamp', // timestamp without time zone
+    'timestamptz', // timestamp with time zone
+    'interval', // duration
+    // Binary & structured
+    'bytea', // binary data
+    'uuid', // universally unique identifier
+    // JSON & XML
+    'json', // textual JSON
+    'jsonb', // binary JSON
+    'xml', // XML format
+    // Money & bitstrings
+    'money', // currency value
+    'bit', // fixed-length bit string
+    'varbit', // variable-length bit string
+    // Network types
+    'inet', // IPv4 or IPv6 address
+    'cidr', // network address
+    'macaddr', // MAC address (6 bytes)
+    'macaddr8' // MAC address (8 bytes)
+];
+/**
+ * Parser-level type aliases accepted by PostgreSQL SQL syntax,
+ * but not present in pg_catalog.pg_type. These are resolved to
+ * real types during parsing and never appear in introspection.
+ */
+const pgCatalogTypeAliases = [
+    ['numeric', ['decimal', 'dec']],
+    ['int4', ['int', 'integer']],
+    ['float8', ['float']],
+    ['bpchar', ['character']],
+    ['varchar', ['character varying']]
+];
 // Type guards for better type safety
 function isParseResult(obj) {
     // A ParseResult is an object that could have stmts (but not required)
@@ -47,11 +104,9 @@ function isWrappedParseResult(obj) {
  * compatibility and wraps them internally for consistent processing.
  */
 class Deparser {
-    formatter;
     tree;
     options;
     constructor(tree, opts = {}) {
-        this.formatter = new sql_formatter_1.SqlFormatter(opts.newline, opts.tab, opts.pretty);
         // Set default options
         this.options = {
             functionDelimiter: '$$',
@@ -88,15 +143,17 @@ class Deparser {
         return new Deparser(query, opts).deparseQuery();
     }
     deparseQuery() {
+        const formatter = new sql_formatter_1.SqlFormatter(this.options.newline, this.options.tab, this.options.pretty);
+        const context = new base_1.DeparserContext({ formatter, prettyMode: this.options.pretty });
         return this.tree
             .map(node => {
             // All nodes should go through the standard deparse method
             // which will route to the appropriate handler
-            const result = this.deparse(node);
+            const result = this.deparse(node, context);
             return result || '';
         })
             .filter(result => result !== '')
-            .join(this.formatter.newline() + this.formatter.newline());
+            .join(context.newline() + context.newline());
     }
     /**
      * Get the appropriate function delimiter based on the body content
@@ -110,10 +167,14 @@ class Deparser {
         }
         return delimiter;
     }
-    deparse(node, context = { parentNodeTypes: [] }) {
+    deparse(node, context) {
         if (node == null) {
             return null;
         }
+        if (!context) {
+            const formatter = new sql_formatter_1.SqlFormatter(this.options.newline, this.options.tab, this.options.pretty);
+            context = new base_1.DeparserContext({ formatter, prettyMode: this.options.pretty });
+        }
         if (typeof node === 'number' || node instanceof Number) {
             return node.toString();
         }
@@ -125,7 +186,11 @@ class Deparser {
             throw new Error(`Error deparsing ${nodeType}: ${error.message}`);
         }
     }
-    visit(node, context = { parentNodeTypes: [] }) {
+    visit(node, context) {
+        if (!context) {
+            const formatter = new sql_formatter_1.SqlFormatter(this.options.newline, this.options.tab, this.options.pretty);
+            context = new base_1.DeparserContext({ formatter, prettyMode: this.options.pretty });
+        }
         const nodeType = this.getNodeType(node);
         // Handle empty objects
         if (!nodeType) {
@@ -134,11 +199,7 @@ class Deparser {
         const nodeData = this.getNodeData(node);
         const methodName = nodeType;
         if (typeof this[methodName] === 'function') {
-            const childContext = {
-                ...context,
-                parentNodeTypes: [...context.parentNodeTypes, nodeType]
-            };
-            const result = this[methodName](nodeData, childContext);
+            const result = this[methodName](nodeData, context);
             return result;
         }
         throw new Error(`Deparser does not handle node type: ${nodeType}`);
@@ -164,7 +225,7 @@ class Deparser {
             .filter((rawStmt) => rawStmt != null)
             .map((rawStmt) => this.RawStmt(rawStmt, context))
             .filter((result) => result !== '')
-            .join(this.formatter.newline() + this.formatter.newline());
+            .join(context.newline() + context.newline());
     }
     RawStmt(node, context) {
         if (!node.stmt) {
@@ -184,7 +245,7 @@ class Deparser {
         }
         if (!node.op || node.op === 'SETOP_NONE') {
             if (node.valuesLists == null) {
-                if (!this.formatter.isPretty() || !node.targetList) {
+                if (!context.isPretty() || !node.targetList) {
                     output.push('SELECT');
                 }
             }
@@ -204,7 +265,7 @@ class Deparser {
                 node.rarg.limitOffset ||
                 node.rarg.withClause);
             if (leftNeedsParens) {
-                output.push(this.formatter.parens(leftStmt));
+                output.push(context.parens(leftStmt));
             }
             else {
                 output.push(leftStmt);
@@ -226,7 +287,7 @@ class Deparser {
                 output.push('ALL');
             }
             if (rightNeedsParens) {
-                output.push(this.formatter.parens(rightStmt));
+                output.push(context.parens(rightStmt));
             }
             else {
                 output.push(rightStmt);
@@ -238,20 +299,20 @@ class Deparser {
             const distinctClause = list_utils_1.ListUtils.unwrapList(node.distinctClause);
             if (distinctClause.length > 0 && Object.keys(distinctClause[0]).length > 0) {
                 const clause = distinctClause
-                    .map(e => this.visit(e, { ...context, select: true }))
+                    .map(e => this.visit(e, context.spawn('SelectStmt', { select: true })))
                     .join(', ');
-                distinctPart = ' DISTINCT ON ' + this.formatter.parens(clause);
+                distinctPart = ' DISTINCT ON ' + context.parens(clause);
             }
             else {
                 distinctPart = ' DISTINCT';
             }
-            if (!this.formatter.isPretty()) {
+            if (!context.isPretty()) {
                 if (distinctClause.length > 0 && Object.keys(distinctClause[0]).length > 0) {
                     output.push('DISTINCT ON');
                     const clause = distinctClause
-                        .map(e => this.visit(e, { ...context, select: true }))
+                        .map(e => this.visit(e, context.spawn('SelectStmt', { select: true })))
                         .join(', ');
-                    output.push(this.formatter.parens(clause));
+                    output.push(context.parens(clause));
                 }
                 else {
                     output.push('DISTINCT');
@@ -260,22 +321,41 @@ class Deparser {
         }
         if (node.targetList) {
             const targetList = list_utils_1.ListUtils.unwrapList(node.targetList);
-            if (this.formatter.isPretty()) {
-                const targetStrings = targetList
-                    .map(e => {
-                    const targetStr = this.visit(e, { ...context, select: true });
-                    if (this.containsMultilineStringLiteral(targetStr)) {
-                        return targetStr;
+            if (context.isPretty()) {
+                if (targetList.length === 1) {
+                    const targetNode = targetList[0];
+                    const target = this.visit(targetNode, context.spawn('SelectStmt', { select: true }));
+                    // 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));
+                        }
                     }
-                    return this.formatter.indent(targetStr);
-                });
-                const formattedTargets = targetStrings.join(',' + this.formatter.newline());
-                output.push('SELECT' + distinctPart);
-                output.push(formattedTargets);
+                    else {
+                        output.push('SELECT' + distinctPart + ' ' + target);
+                    }
+                }
+                else {
+                    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());
+                    output.push('SELECT' + distinctPart);
+                    output.push(formattedTargets);
+                }
             }
             else {
                 const targets = targetList
-                    .map(e => this.visit(e, { ...context, select: true }))
+                    .map(e => this.visit(e, context.spawn('SelectStmt', { select: true })))
                     .join(', ');
                 output.push(targets);
             }
@@ -287,22 +367,22 @@ class Deparser {
         if (node.fromClause) {
             const fromList = list_utils_1.ListUtils.unwrapList(node.fromClause);
             const fromItems = fromList
-                .map(e => this.deparse(e, { ...context, from: true }))
+                .map(e => this.deparse(e, context.spawn('SelectStmt', { from: true })))
                 .join(', ');
             output.push('FROM ' + fromItems.trim());
         }
         if (node.whereClause) {
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 output.push('WHERE');
                 const whereExpr = this.visit(node.whereClause, context);
-                const lines = whereExpr.split(this.formatter.newline());
+                const lines = whereExpr.split(context.newline());
                 const indentedLines = lines.map((line, index) => {
                     if (index === 0) {
-                        return this.formatter.indent(line);
+                        return context.indent(line);
                     }
                     return line;
                 });
-                output.push(indentedLines.join(this.formatter.newline()));
+                output.push(indentedLines.join(context.newline()));
             }
             else {
                 output.push('WHERE');
@@ -310,45 +390,61 @@ class Deparser {
             }
         }
         if (node.valuesLists) {
-            output.push('VALUES');
-            const lists = list_utils_1.ListUtils.unwrapList(node.valuesLists).map(list => {
-                const values = list_utils_1.ListUtils.unwrapList(list).map(val => this.visit(val, context));
-                return this.formatter.parens(values.join(', '));
-            });
-            output.push(lists.join(', '));
+            if (context.isPretty()) {
+                output.push('VALUES');
+                const lists = list_utils_1.ListUtils.unwrapList(node.valuesLists).map(list => {
+                    const values = list_utils_1.ListUtils.unwrapList(list).map(val => this.visit(val, context));
+                    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'));
+            }
+            else {
+                output.push('VALUES');
+                const lists = list_utils_1.ListUtils.unwrapList(node.valuesLists).map(list => {
+                    const values = list_utils_1.ListUtils.unwrapList(list).map(val => this.visit(val, context));
+                    return context.parens(values.join(', '));
+                });
+                output.push(lists.join(', '));
+            }
         }
         if (node.groupClause) {
             const groupList = list_utils_1.ListUtils.unwrapList(node.groupClause);
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 const groupItems = groupList
                     .map(e => {
-                    const groupStr = this.visit(e, { ...context, group: true });
+                    const groupStr = this.visit(e, context.spawn('SelectStmt', { group: true, indentLevel: context.indentLevel + 1 }));
                     if (this.containsMultilineStringLiteral(groupStr)) {
                         return groupStr;
                     }
-                    return this.formatter.indent(groupStr);
+                    return context.indent(groupStr);
                 })
-                    .join(',' + this.formatter.newline());
+                    .join(',' + context.newline());
                 output.push('GROUP BY');
                 output.push(groupItems);
             }
             else {
                 output.push('GROUP BY');
                 const groupItems = groupList
-                    .map(e => this.visit(e, { ...context, group: true }))
+                    .map(e => this.visit(e, context.spawn('SelectStmt', { group: true })))
                     .join(', ');
                 output.push(groupItems);
             }
         }
         if (node.havingClause) {
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 output.push('HAVING');
                 const havingStr = this.visit(node.havingClause, context);
                 if (this.containsMultilineStringLiteral(havingStr)) {
                     output.push(havingStr);
                 }
                 else {
-                    output.push(this.formatter.indent(havingStr));
+                    output.push(context.indent(havingStr));
                 }
             }
             else {
@@ -366,23 +462,23 @@ class Deparser {
         }
         if (node.sortClause) {
             const sortList = list_utils_1.ListUtils.unwrapList(node.sortClause);
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 const sortItems = sortList
                     .map(e => {
-                    const sortStr = this.visit(e, { ...context, sort: true });
+                    const sortStr = this.visit(e, context.spawn('SelectStmt', { sort: true, indentLevel: context.indentLevel + 1 }));
                     if (this.containsMultilineStringLiteral(sortStr)) {
                         return sortStr;
                     }
-                    return this.formatter.indent(sortStr);
+                    return context.indent(sortStr);
                 })
-                    .join(',' + this.formatter.newline());
+                    .join(',' + context.newline());
                 output.push('ORDER BY');
                 output.push(sortItems);
             }
             else {
                 output.push('ORDER BY');
                 const sortItems = sortList
-                    .map(e => this.visit(e, { ...context, sort: true }))
+                    .map(e => this.visit(e, context.spawn('SelectStmt', { sort: true })))
                     .join(', ');
                 output.push(sortItems);
             }
@@ -400,9 +496,9 @@ class Deparser {
                 .join(' ');
             output.push(lockingClauses);
         }
-        if (this.formatter.isPretty()) {
+        if (context.isPretty()) {
             const filteredOutput = output.filter(item => item.trim() !== '');
-            return filteredOutput.join(this.formatter.newline());
+            return filteredOutput.join(context.newline());
         }
         return output.join(' ');
     }
@@ -414,13 +510,13 @@ class Deparser {
         switch (kind) {
             case 'AEXPR_OP':
                 if (lexpr && rexpr) {
-                    const operator = this.deparseOperatorName(name);
+                    const operator = this.deparseOperatorName(name, context);
                     let leftExpr = this.visit(lexpr, context);
                     let rightExpr = this.visit(rexpr, context);
                     // Check if left expression needs parentheses
                     let leftNeedsParens = false;
                     if (lexpr && 'A_Expr' in lexpr && lexpr.A_Expr?.kind === 'AEXPR_OP') {
-                        const leftOp = this.deparseOperatorName(list_utils_1.ListUtils.unwrapList(lexpr.A_Expr.name));
+                        const leftOp = this.deparseOperatorName(list_utils_1.ListUtils.unwrapList(lexpr.A_Expr.name), context);
                         if (this.needsParentheses(leftOp, operator, 'left')) {
                             leftNeedsParens = true;
                         }
@@ -429,12 +525,12 @@ class Deparser {
                         leftNeedsParens = true;
                     }
                     if (leftNeedsParens) {
-                        leftExpr = this.formatter.parens(leftExpr);
+                        leftExpr = context.parens(leftExpr);
                     }
                     // Check if right expression needs parentheses
                     let rightNeedsParens = false;
                     if (rexpr && 'A_Expr' in rexpr && rexpr.A_Expr?.kind === 'AEXPR_OP') {
-                        const rightOp = this.deparseOperatorName(list_utils_1.ListUtils.unwrapList(rexpr.A_Expr.name));
+                        const rightOp = this.deparseOperatorName(list_utils_1.ListUtils.unwrapList(rexpr.A_Expr.name), context);
                         if (this.needsParentheses(rightOp, operator, 'right')) {
                             rightNeedsParens = true;
                         }
@@ -443,42 +539,42 @@ class Deparser {
                         rightNeedsParens = true;
                     }
                     if (rightNeedsParens) {
-                        rightExpr = this.formatter.parens(rightExpr);
+                        rightExpr = context.parens(rightExpr);
                     }
-                    return this.formatter.format([leftExpr, operator, rightExpr]);
+                    return context.format([leftExpr, operator, rightExpr]);
                 }
                 else if (rexpr) {
-                    return this.formatter.format([
-                        this.deparseOperatorName(name),
+                    return context.format([
+                        this.deparseOperatorName(name, context),
                         this.visit(rexpr, context)
                     ]);
                 }
                 break;
             case 'AEXPR_OP_ANY':
-                return this.formatter.format([
+                return context.format([
                     this.visit(lexpr, context),
-                    this.deparseOperatorName(name),
+                    this.deparseOperatorName(name, context),
                     'ANY',
-                    this.formatter.parens(this.visit(rexpr, context))
+                    context.parens(this.visit(rexpr, context))
                 ]);
             case 'AEXPR_OP_ALL':
-                return this.formatter.format([
+                return context.format([
                     this.visit(lexpr, context),
-                    this.deparseOperatorName(name),
+                    this.deparseOperatorName(name, context),
                     'ALL',
-                    this.formatter.parens(this.visit(rexpr, context))
+                    context.parens(this.visit(rexpr, context))
                 ]);
             case 'AEXPR_DISTINCT': {
                 let leftExpr = this.visit(lexpr, context);
                 let rightExpr = this.visit(rexpr, context);
                 // Add parentheses for complex expressions
                 if (lexpr && this.isComplexExpression(lexpr)) {
-                    leftExpr = this.formatter.parens(leftExpr);
+                    leftExpr = context.parens(leftExpr);
                 }
                 if (rexpr && this.isComplexExpression(rexpr)) {
-                    rightExpr = this.formatter.parens(rightExpr);
+                    rightExpr = context.parens(rightExpr);
                 }
-                return this.formatter.format([
+                return context.format([
                     leftExpr,
                     'IS DISTINCT FROM',
                     rightExpr
@@ -489,75 +585,75 @@ class Deparser {
                 let rightExpr = this.visit(rexpr, context);
                 // Add parentheses for complex expressions
                 if (lexpr && this.isComplexExpression(lexpr)) {
-                    leftExpr = this.formatter.parens(leftExpr);
+                    leftExpr = context.parens(leftExpr);
                 }
                 if (rexpr && this.isComplexExpression(rexpr)) {
-                    rightExpr = this.formatter.parens(rightExpr);
+                    rightExpr = context.parens(rightExpr);
                 }
-                return this.formatter.format([
+                return context.format([
                     leftExpr,
                     'IS NOT DISTINCT FROM',
                     rightExpr
                 ]);
             }
             case 'AEXPR_NULLIF':
-                return this.formatter.format([
+                return context.format([
                     'NULLIF',
-                    this.formatter.parens([
+                    context.parens([
                         this.visit(lexpr, context),
                         this.visit(rexpr, context)
                     ].join(', '))
                 ]);
             case 'AEXPR_IN':
-                const inOperator = this.deparseOperatorName(name);
+                const inOperator = this.deparseOperatorName(name, context);
                 if (inOperator === '<>' || inOperator === '!=') {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'NOT IN',
-                        this.formatter.parens(this.visit(rexpr, context))
+                        context.parens(this.visit(rexpr, context))
                     ]);
                 }
                 else {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'IN',
-                        this.formatter.parens(this.visit(rexpr, context))
+                        context.parens(this.visit(rexpr, context))
                     ]);
                 }
             case 'AEXPR_LIKE':
-                const likeOp = this.deparseOperatorName(name);
+                const likeOp = this.deparseOperatorName(name, context);
                 if (likeOp === '!~~') {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'NOT LIKE',
                         this.visit(rexpr, context)
                     ]);
                 }
                 else {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'LIKE',
                         this.visit(rexpr, context)
                     ]);
                 }
             case 'AEXPR_ILIKE':
-                const ilikeOp = this.deparseOperatorName(name);
+                const ilikeOp = this.deparseOperatorName(name, context);
                 if (ilikeOp === '!~~*') {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'NOT ILIKE',
                         this.visit(rexpr, context)
                     ]);
                 }
                 else {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'ILIKE',
                         this.visit(rexpr, context)
                     ]);
                 }
             case 'AEXPR_SIMILAR':
-                const similarOp = this.deparseOperatorName(name);
+                const similarOp = this.deparseOperatorName(name, context);
                 let rightExpr;
                 if (rexpr && 'FuncCall' in rexpr &&
                     rexpr.FuncCall?.funcname?.length === 2 &&
@@ -573,39 +669,39 @@ class Deparser {
                     rightExpr = this.visit(rexpr, context);
                 }
                 if (similarOp === '!~') {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'NOT SIMILAR TO',
                         rightExpr
                     ]);
                 }
                 else {
-                    return this.formatter.format([
+                    return context.format([
                         this.visit(lexpr, context),
                         'SIMILAR TO',
                         rightExpr
                     ]);
                 }
             case 'AEXPR_BETWEEN':
-                return this.formatter.format([
+                return context.format([
                     this.visit(lexpr, context),
                     'BETWEEN',
                     this.visitBetweenRange(rexpr, context)
                 ]);
             case 'AEXPR_NOT_BETWEEN':
-                return this.formatter.format([
+                return context.format([
                     this.visit(lexpr, context),
                     'NOT BETWEEN',
                     this.visitBetweenRange(rexpr, context)
                 ]);
             case 'AEXPR_BETWEEN_SYM':
-                return this.formatter.format([
+                return context.format([
                     this.visit(lexpr, context),
                     'BETWEEN SYMMETRIC',
                     this.visitBetweenRange(rexpr, context)
                 ]);
             case 'AEXPR_NOT_BETWEEN_SYM':
-                return this.formatter.format([
+                return context.format([
                     this.visit(lexpr, context),
                     'NOT BETWEEN SYMMETRIC',
                     this.visitBetweenRange(rexpr, context)
@@ -613,7 +709,7 @@ class Deparser {
         }
         throw new Error(`Unhandled A_Expr kind: ${kind}`);
     }
-    deparseOperatorName(name) {
+    deparseOperatorName(name, context) {
         if (!name || name.length === 0) {
             return '';
         }
@@ -621,7 +717,7 @@ class Deparser {
             if (n.String) {
                 return n.String.sval || n.String.str;
             }
-            return this.visit(n, { parentNodeTypes: [] });
+            return this.visit(n, context);
         });
         if (parts.length > 1) {
             return `OPERATOR(${parts.join('.')})`;
@@ -684,6 +780,64 @@ class Deparser {
             node.SubLink ||
             node.A_Expr);
     }
+    isComplexSelectTarget(node) {
+        if (!node)
+            return false;
+        if (node.ResTarget?.val) {
+            return this.isComplexExpression(node.ResTarget.val);
+        }
+        // Always complex: CASE expressions
+        if (node.CaseExpr)
+            return true;
+        // Always complex: Subqueries and subselects
+        if (node.SubLink)
+            return true;
+        // Always complex: Boolean tests and expressions
+        if (node.NullTest || node.BooleanTest || node.BoolExpr)
+            return true;
+        // COALESCE and similar functions - complex if multiple arguments
+        if (node.CoalesceExpr) {
+            const args = node.CoalesceExpr.args;
+            if (args && Array.isArray(args) && args.length > 1)
+                return true;
+        }
+        // Function calls - complex if multiple args or has clauses
+        if (node.FuncCall) {
+            const funcCall = node.FuncCall;
+            const args = funcCall.args ? (Array.isArray(funcCall.args) ? funcCall.args : [funcCall.args]) : [];
+            // Complex if has window clause, filter, order by, etc.
+            if (funcCall.over || funcCall.agg_filter || funcCall.agg_order || funcCall.agg_distinct) {
+                return true;
+            }
+            // Complex if multiple arguments
+            if (args.length > 1)
+                return true;
+            if (args.length === 1) {
+                return this.isComplexSelectTarget(args[0]);
+            }
+        }
+        if (node.A_Expr) {
+            const expr = node.A_Expr;
+            // Check if operands are complex
+            if (expr.lexpr && this.isComplexSelectTarget(expr.lexpr))
+                return true;
+            if (expr.rexpr && this.isComplexSelectTarget(expr.rexpr))
+                return true;
+            return false;
+        }
+        if (node.TypeCast) {
+            return this.isComplexSelectTarget(node.TypeCast.arg);
+        }
+        if (node.A_ArrayExpr)
+            return true;
+        if (node.A_Indirection) {
+            return this.isComplexSelectTarget(node.A_Indirection.arg);
+        }
+        if (node.A_Const || node.ColumnRef || node.ParamRef || node.A_Star) {
+            return false;
+        }
+        return false;
+    }
     visitBetweenRange(rexpr, context) {
         if (rexpr && 'List' in rexpr && rexpr.List?.items) {
             const items = rexpr.List.items.map((item) => this.visit(item, context));
@@ -700,9 +854,16 @@ class Deparser {
         output.push(this.RangeVar(node.relation, context));
         if (node.cols) {
             const cols = list_utils_1.ListUtils.unwrapList(node.cols);
-            const insertContext = { ...context, insertColumns: true };
+            const insertContext = context.spawn('InsertStmt', { insertColumns: true });
             const columnNames = cols.map(col => this.visit(col, insertContext));
-            output.push(this.formatter.parens(columnNames.join(', ')));
+            if (context.isPretty()) {
+                // Always format columns in multiline parentheses for pretty printing
+                const indentedColumns = columnNames.map(col => context.indent(col));
+                output.push('(\n' + indentedColumns.join(',\n') + '\n)');
+            }
+            else {
+                output.push(context.parens(columnNames.join(', ')));
+            }
         }
         if (node.selectStmt) {
             output.push(this.visit(node.selectStmt, context));
@@ -723,7 +884,7 @@ class Deparser {
                 else if (infer.indexElems) {
                     const elems = list_utils_1.ListUtils.unwrapList(infer.indexElems);
                     const indexElems = elems.map(elem => this.visit(elem, context));
-                    output.push(this.formatter.parens(indexElems.join(', ')));
+                    output.push(context.parens(indexElems.join(', ')));
                 }
                 // Handle WHERE clause for conflict detection
                 if (infer.whereClause) {
@@ -739,12 +900,12 @@ class Deparser {
                     if (firstTarget.ResTarget?.val?.MultiAssignRef && targetList.every(target => target.ResTarget?.val?.MultiAssignRef)) {
                         const sortedTargets = targetList.sort((a, b) => a.ResTarget.val.MultiAssignRef.colno - b.ResTarget.val.MultiAssignRef.colno);
                         const names = sortedTargets.map(target => target.ResTarget.name);
-                        output.push(this.formatter.parens(names.join(', ')));
+                        output.push(context.parens(names.join(', ')));
                         output.push('=');
                         output.push(this.visit(firstTarget.ResTarget.val.MultiAssignRef.source, context));
                     }
                     else {
-                        const updateContext = { ...context, update: true };
+                        const updateContext = context.spawn('UpdateStmt', { update: true });
                         const targets = targetList.map(target => this.visit(target, updateContext));
                         output.push(targets.join(', '));
                     }
@@ -798,12 +959,12 @@ class Deparser {
                         }
                     }
                     const names = relatedTargets.map(t => t.ResTarget.name);
-                    const multiAssignment = `${this.formatter.parens(names.join(', '))} = ${this.visit(multiAssignRef.source, context)}`;
+                    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, update: true }));
+                    assignmentParts.push(this.visit(target, context.spawn('UpdateStmt', { update: true })));
                     processedTargets.add(i);
                 }
             }
@@ -895,14 +1056,14 @@ class Deparser {
         }
         if (node.ctes && node.ctes.length > 0) {
             const ctes = list_utils_1.ListUtils.unwrapList(node.ctes);
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 const cteStrings = ctes.map((cte, index) => {
                     const cteStr = this.visit(cte, context);
-                    const prefix = index === 0 ? this.formatter.newline() : ',' + this.formatter.newline();
+                    const prefix = index === 0 ? context.newline() : ',' + context.newline();
                     if (this.containsMultilineStringLiteral(cteStr)) {
                         return prefix + cteStr;
                     }
-                    return prefix + this.formatter.indent(cteStr);
+                    return prefix + context.indent(cteStr);
                 });
                 output.push(cteStrings.join(''));
             }
@@ -988,14 +1149,14 @@ class Deparser {
         if (context.bool) {
             formatStr = '(%s)';
         }
-        const boolContext = { ...context, bool: true };
+        const boolContext = context.spawn('BoolExpr', { bool: true });
         // explanation of our syntax/fix below:
         // return formatStr.replace('%s', andArgs); // ❌ Interprets $ as special syntax
         // return formatStr.replace('%s', () => andArgs); // ✅ Function callback prevents interpretation
         switch (boolop) {
             case 'AND_EXPR':
-                if (this.formatter.isPretty() && args.length > 1) {
-                    const andArgs = args.map(arg => this.visit(arg, boolContext)).join(this.formatter.newline() + '  AND ');
+                if (context.isPretty() && args.length > 1) {
+                    const andArgs = args.map(arg => this.visit(arg, boolContext)).join(context.newline() + context.indent('AND '));
                     return formatStr.replace('%s', () => andArgs);
                 }
                 else {
@@ -1003,8 +1164,8 @@ class Deparser {
                     return formatStr.replace('%s', () => andArgs);
                 }
             case 'OR_EXPR':
-                if (this.formatter.isPretty() && args.length > 1) {
-                    const orArgs = args.map(arg => this.visit(arg, boolContext)).join(this.formatter.newline() + '  OR ');
+                if (context.isPretty() && args.length > 1) {
+                    const orArgs = args.map(arg => this.visit(arg, boolContext)).join(context.newline() + context.indent('OR '));
                     return formatStr.replace('%s', () => orArgs);
                 }
                 else {
@@ -1135,9 +1296,9 @@ class Deparser {
             const timezone = this.visit(args[0], context);
             // Add parentheses around timestamp if it contains arithmetic operations
             if (args[1] && 'A_Expr' in args[1] && args[1].A_Expr?.kind === 'AEXPR_OP') {
-                const op = this.deparseOperatorName(list_utils_1.ListUtils.unwrapList(args[1].A_Expr.name));
+                const op = this.deparseOperatorName(list_utils_1.ListUtils.unwrapList(args[1].A_Expr.name), context);
                 if (op === '+' || op === '-' || op === '*' || op === '/') {
-                    timestamp = this.formatter.parens(timestamp);
+                    timestamp = context.parens(timestamp);
                 }
             }
             return `${timestamp} AT TIME ZONE ${timezone}`;
@@ -1207,14 +1368,14 @@ class Deparser {
                     windowParts.push(`ORDER BY ${orderStrs.join(', ')}`);
                 }
                 // Handle window frame specifications using the dedicated formatWindowFrame method
-                const frameClause = this.formatWindowFrame(node.over);
+                const frameClause = this.formatWindowFrame(node.over, context.spawn('FuncCall'));
                 if (frameClause) {
                     windowParts.push(frameClause);
                 }
                 if (windowParts.length > 0) {
-                    if (this.formatter.isPretty() && windowParts.length > 1) {
-                        const formattedParts = windowParts.map(part => this.formatter.indent(part));
-                        result += ` OVER (${this.formatter.newline()}${formattedParts.join(this.formatter.newline())}${this.formatter.newline()})`;
+                    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(' ')})`;
@@ -1494,9 +1655,6 @@ class Deparser {
                 return output.join(' ');
             }
             if (catalog === 'pg_catalog') {
-                const builtinTypes = ['int2', 'int4', 'int8', 'float4', 'float8', 'numeric', 'decimal',
-                    'varchar', 'char', 'bpchar', 'text', 'bool', 'date', 'time', 'timestamp',
-                    'timestamptz', 'interval', 'bytea', 'uuid', 'json', 'jsonb'];
                 let typeName = `${catalog}.${type}`;
                 if (type === 'bpchar' && args) {
                     typeName = 'char';
@@ -1582,7 +1740,7 @@ class Deparser {
                 }
                 return this.quoteIfNeeded(colStr);
             });
-            output.push('AS', this.quoteIfNeeded(name) + this.formatter.parens(quotedColnames.join(', ')));
+            output.push('AS', this.quoteIfNeeded(name) + context.parens(quotedColnames.join(', ')));
         }
         else {
             output.push('AS', this.quoteIfNeeded(name));
@@ -1594,7 +1752,7 @@ class Deparser {
         // Handle ONLY keyword for inheritance control (but not for type definitions, ALTER TYPE, or CREATE FOREIGN TABLE)
         if (node && (!('inh' in node) || node.inh === undefined) &&
             !context.parentNodeTypes.includes('CompositeTypeStmt') &&
-            !context.parentNodeTypes.includes('AlterTypeStmt') &&
+            (!context.parentNodeTypes.includes('AlterTypeStmt') && context.objtype !== 'OBJECT_TYPE') &&
             !context.parentNodeTypes.includes('CreateForeignTableStmt')) {
             output.push('ONLY');
         }
@@ -1791,6 +1949,18 @@ class Deparser {
                 return `pg_catalog.${typeName}`;
         }
     }
+    isPgCatalogType(typeName) {
+        const cleanTypeName = typeName.replace(/^pg_catalog\./, '');
+        if (pgCatalogTypes.includes(cleanTypeName)) {
+            return true;
+        }
+        for (const [realType, aliases] of pgCatalogTypeAliases) {
+            if (aliases.includes(cleanTypeName)) {
+                return true;
+            }
+        }
+        return false;
+    }
     A_ArrayExpr(node, context) {
         const elements = list_utils_1.ListUtils.unwrapList(node.elements);
         const elementStrs = elements.map(el => this.visit(el, context));
@@ -1842,26 +2012,26 @@ class Deparser {
             output.push(this.visit(node.arg, context));
         }
         const args = list_utils_1.ListUtils.unwrapList(node.args);
-        if (this.formatter.isPretty() && args.length > 0) {
+        if (context.isPretty() && args.length > 0) {
             for (const arg of args) {
                 const whenClause = this.visit(arg, context);
                 if (this.containsMultilineStringLiteral(whenClause)) {
-                    output.push(this.formatter.newline() + whenClause);
+                    output.push(context.newline() + whenClause);
                 }
                 else {
-                    output.push(this.formatter.newline() + this.formatter.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(this.formatter.newline() + 'ELSE ' + elseResult);
+                    output.push(context.newline() + 'ELSE ' + elseResult);
                 }
                 else {
-                    output.push(this.formatter.newline() + this.formatter.indent('ELSE ' + elseResult));
+                    output.push(context.newline() + context.indent('ELSE ' + elseResult));
                 }
             }
-            output.push(this.formatter.newline() + 'END');
+            output.push(context.newline() + 'END');
             return output.join(' ');
         }
         else {
@@ -1884,28 +2054,29 @@ class Deparser {
     TypeCast(node, context) {
         const arg = this.visit(node.arg, context);
         const typeName = this.TypeName(node.typeName, context);
-        // Check if this is a bpchar typecast that should use traditional char syntax
-        if (typeName === 'bpchar' && node.typeName && node.typeName.names) {
-            const names = list_utils_1.ListUtils.unwrapList(node.typeName.names);
-            if (names.length === 2 &&
-                names[0].String?.sval === 'pg_catalog' &&
-                names[1].String?.sval === 'bpchar') {
-                return `char ${arg}`;
+        // Check if this is a bpchar typecast that should preserve original syntax for AST consistency
+        if (typeName === 'bpchar' || typeName === 'pg_catalog.bpchar') {
+            const names = node.typeName?.names;
+            const isQualifiedBpchar = names && names.length === 2 &&
+                names[0]?.String?.sval === 'pg_catalog' &&
+                names[1]?.String?.sval === 'bpchar';
+            if (isQualifiedBpchar) {
+                return `CAST(${arg} AS ${typeName})`;
             }
         }
-        // Check if the argument is a complex expression that should preserve CAST syntax
-        const argType = this.getNodeType(node.arg);
-        const isComplexExpression = argType === 'A_Expr' || argType === 'FuncCall' || argType === 'OpExpr';
-        if (!isComplexExpression && (typeName.startsWith('interval') ||
-            typeName.startsWith('char') ||
-            typeName === '"char"' ||
-            typeName.startsWith('bpchar') ||
-            typeName === 'bytea' ||
-            typeName === 'orderedarray' ||
-            typeName === 'date')) {
-            // Remove pg_catalog prefix for :: syntax
-            const cleanTypeName = typeName.replace('pg_catalog.', '');
-            return `${arg}::${cleanTypeName}`;
+        if (this.isPgCatalogType(typeName)) {
+            const argType = this.getNodeType(node.arg);
+            const isSimpleArgument = argType === 'A_Const' || argType === 'ColumnRef';
+            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 cleanTypeName = typeName.replace('pg_catalog.', '');
+                    return `${arg}::${cleanTypeName}`;
+                }
+            }
         }
         return `CAST(${arg} AS ${typeName})`;
     }
@@ -1928,7 +2099,7 @@ class Deparser {
     }
     BooleanTest(node, context) {
         const output = [];
-        const boolContext = { ...context, bool: true };
+        const boolContext = context.spawn('BooleanTest', { bool: true });
         output.push(this.visit(node.arg, boolContext));
         switch (node.booltesttype) {
             case 'IS_TRUE':
@@ -2079,24 +2250,31 @@ class Deparser {
                 const elementStrs = elements.map(el => {
                     return this.deparse(el, context);
                 });
-                output.push(this.formatter.parens(elementStrs.join(', ')));
+                output.push(context.parens(elementStrs.join(', ')));
             }
         }
         else if (node.tableElts) {
             const elements = list_utils_1.ListUtils.unwrapList(node.tableElts);
             const elementStrs = elements.map(el => {
-                return this.deparse(el, context);
+                return this.deparse(el, context.spawn('CreateStmt'));
             });
-            if (this.formatter.isPretty()) {
-                const formattedElements = elementStrs.map(el => this.formatter.indent(el)).join(',' + this.formatter.newline());
-                output.push('(' + this.formatter.newline() + formattedElements + this.formatter.newline() + ')');
+            if (context.isPretty()) {
+                const formattedElements = elementStrs.map(el => {
+                    const trimmedEl = el.trim();
+                    // Remove leading newlines from constraint elements to avoid extra blank lines
+                    if (trimmedEl.startsWith('\n')) {
+                        return context.indent(trimmedEl.substring(1));
+                    }
+                    return context.indent(trimmedEl);
+                }).join(',' + context.newline());
+                output.push('(' + context.newline() + formattedElements + context.newline() + ')');
             }
             else {
-                output.push(this.formatter.parens(elementStrs.join(', ')));
+                output.push(context.parens(elementStrs.join(', ')));
             }
         }
         else if (!node.partbound) {
-            output.push(this.formatter.parens(''));
+            output.push(context.parens(''));
         }
         if (node.partbound && node.inhRelations && node.inhRelations.length > 0) {
             output.push('PARTITION OF');
@@ -2139,7 +2317,7 @@ class Deparser {
             output.push('INHERITS');
             const inherits = list_utils_1.ListUtils.unwrapList(node.inhRelations);
             const inheritStrs = inherits.map(rel => this.visit(rel, context));
-            output.push(this.formatter.parens(inheritStrs.join(', ')));
+            output.push(context.parens(inheritStrs.join(', ')));
         }
         if (node.partspec) {
             output.push('PARTITION BY');
@@ -2177,7 +2355,7 @@ class Deparser {
         }
         // Handle table options like WITH (fillfactor=10)
         if (node.options && node.options.length > 0) {
-            const createStmtContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateStmt'] };
+            const createStmtContext = context.spawn('CreateStmt');
             const optionStrs = node.options.map((option) => {
                 return this.deparse(option, createStmtContext);
             });
@@ -2200,7 +2378,7 @@ class Deparser {
         }
         if (node.fdwoptions && node.fdwoptions.length > 0) {
             output.push('OPTIONS');
-            const columnContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'ColumnDef'] };
+            const columnContext = context.spawn('ColumnDef');
             const options = list_utils_1.ListUtils.unwrapList(node.fdwoptions).map(opt => this.visit(opt, columnContext));
             output.push(`(${options.join(', ')})`);
         }
@@ -2210,7 +2388,7 @@ class Deparser {
         if (node.constraints) {
             const constraints = list_utils_1.ListUtils.unwrapList(node.constraints);
             const constraintStrs = constraints.map(constraint => {
-                const columnConstraintContext = { ...context, isColumnConstraint: true };
+                const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
                 return this.visit(constraint, columnConstraintContext);
             });
             output.push(...constraintStrs);
@@ -2250,9 +2428,25 @@ class Deparser {
                 }
                 break;
             case 'CONSTR_CHECK':
-                output.push('CHECK');
+                if (context.isPretty() && !context.isColumnConstraint) {
+                    output.push('\n' + context.indent('CHECK'));
+                }
+                else {
+                    output.push('CHECK');
+                }
                 if (node.raw_expr) {
-                    output.push(this.formatter.parens(this.visit(node.raw_expr, context)));
+                    if (context.isPretty()) {
+                        const checkExpr = this.visit(node.raw_expr, context);
+                        if (checkExpr.includes('\n')) {
+                            output.push('(\n' + context.indent(checkExpr) + '\n)');
+                        }
+                        else {
+                            output.push(`(${checkExpr})`);
+                        }
+                    }
+                    else {
+                        output.push(context.parens(this.visit(node.raw_expr, context)));
+                    }
                 }
                 // Handle NOT VALID for check constraints
                 if (node.skip_validation) {
@@ -2273,7 +2467,7 @@ class Deparser {
                 }
                 output.push('AS');
                 if (node.raw_expr) {
-                    output.push(this.formatter.parens(this.visit(node.raw_expr, context)));
+                    output.push(context.parens(this.visit(node.raw_expr, context)));
                 }
                 output.push('STORED');
                 break;
@@ -2331,7 +2525,12 @@ class Deparser {
                 }
                 break;
             case 'CONSTR_UNIQUE':
-                output.push('UNIQUE');
+                if (context.isPretty() && !context.isColumnConstraint) {
+                    output.push('\n' + context.indent('UNIQUE'));
+                }
+                else {
+                    output.push('UNIQUE');
+                }
                 if (node.nulls_not_distinct) {
                     output.push('NULLS NOT DISTINCT');
                 }
@@ -2349,33 +2548,77 @@ class Deparser {
             case 'CONSTR_FOREIGN':
                 // Only add "FOREIGN KEY" for table-level constraints, not column-level constraints
                 if (!context.isColumnConstraint) {
-                    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})`);
+                    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('\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('REFERENCES');
+                    }
+                }
+                else {
+                    output.push('REFERENCES');
                 }
-                output.push('REFERENCES');
                 if (node.pktable) {
-                    output.push(this.RangeVar(node.pktable, context));
+                    if (context.isPretty() && !context.isColumnConstraint) {
+                        const lastIndex = output.length - 1;
+                        if (lastIndex >= 0 && output[lastIndex].includes('REFERENCES')) {
+                            output[lastIndex] += ' ' + this.RangeVar(node.pktable, context);
+                        }
+                        else {
+                            output.push(this.RangeVar(node.pktable, context));
+                        }
+                    }
+                    else {
+                        output.push(this.RangeVar(node.pktable, context));
+                    }
                 }
                 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(', ');
-                    output.push(`(${pkAttrs})`);
+                    if (context.isPretty() && !context.isColumnConstraint) {
+                        const lastIndex = output.length - 1;
+                        if (lastIndex >= 0) {
+                            output[lastIndex] += ` (${pkAttrs})`;
+                        }
+                        else {
+                            output.push(`(${pkAttrs})`);
+                        }
+                    }
+                    else {
+                        output.push(`(${pkAttrs})`);
+                    }
                 }
                 if (node.fk_matchtype && node.fk_matchtype !== 's') {
+                    let matchClause = '';
                     switch (node.fk_matchtype) {
                         case 'f':
-                            output.push('MATCH FULL');
+                            matchClause = 'MATCH FULL';
                             break;
                         case 'p':
-                            output.push('MATCH PARTIAL');
+                            matchClause = 'MATCH PARTIAL';
                             break;
                     }
+                    if (context.isPretty() && !context.isColumnConstraint) {
+                        output.push('\n' + context.indent(matchClause));
+                    }
+                    else {
+                        output.push(matchClause);
+                    }
                 }
                 if (node.fk_upd_action && node.fk_upd_action !== 'a') {
                     let updateClause = 'ON UPDATE ';
@@ -2393,8 +2636,8 @@ class Deparser {
                             updateClause += 'SET DEFAULT';
                             break;
                     }
-                    if (this.formatter.isPretty()) {
-                        output.push('\n' + this.formatter.indent(updateClause));
+                    if (context.isPretty()) {
+                        output.push('\n' + context.indent(updateClause));
                     }
                     else {
                         output.push('ON UPDATE');
@@ -2417,8 +2660,8 @@ class Deparser {
                             deleteClause += 'SET DEFAULT';
                             break;
                     }
-                    if (this.formatter.isPretty()) {
-                        output.push('\n' + this.formatter.indent(deleteClause));
+                    if (context.isPretty()) {
+                        output.push('\n' + context.indent(deleteClause));
                     }
                     else {
                         output.push('ON DELETE');
@@ -2427,7 +2670,12 @@ class Deparser {
                 }
                 // Handle NOT VALID for foreign key constraints - only for table constraints, not domain constraints
                 if (node.skip_validation && !context.isDomainConstraint) {
-                    output.push('NOT VALID');
+                    if (context.isPretty() && !context.isColumnConstraint) {
+                        output.push('\n' + context.indent('NOT VALID'));
+                    }
+                    else {
+                        output.push('NOT VALID');
+                    }
                 }
                 break;
             case 'CONSTR_ATTR_DEFERRABLE':
@@ -2481,13 +2729,13 @@ class Deparser {
         // 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.deferrable) {
-                if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
-                    output.push('\n' + this.formatter.indent('DEFERRABLE'));
+                if (context.isPretty() && node.contype === 'CONSTR_FOREIGN') {
+                    output.push('\n' + context.indent('DEFERRABLE'));
                     if (node.initdeferred === true) {
-                        output.push('\n' + this.formatter.indent('INITIALLY DEFERRED'));
+                        output.push('\n' + context.indent('INITIALLY DEFERRED'));
                     }
                     else if (node.initdeferred === false) {
-                        output.push('\n' + this.formatter.indent('INITIALLY IMMEDIATE'));
+                        output.push('\n' + context.indent('INITIALLY IMMEDIATE'));
                     }
                 }
                 else {
@@ -2501,15 +2749,15 @@ class Deparser {
                 }
             }
             else if (node.deferrable === false) {
-                if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
-                    output.push('\n' + this.formatter.indent('NOT DEFERRABLE'));
+                if (context.isPretty() && node.contype === 'CONSTR_FOREIGN') {
+                    output.push('\n' + context.indent('NOT DEFERRABLE'));
                 }
                 else {
                     output.push('NOT DEFERRABLE');
                 }
             }
         }
-        if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
+        if (context.isPretty() && node.contype === 'CONSTR_FOREIGN') {
             let result = '';
             for (let i = 0; i < output.length; i++) {
                 if (output[i].startsWith('\n')) {
@@ -2527,12 +2775,12 @@ class Deparser {
         return output.join(' ');
     }
     SubLink(node, context) {
-        const subselect = this.formatter.parens(this.visit(node.subselect, context));
+        const subselect = context.parens(this.visit(node.subselect, context));
         switch (node.subLinkType) {
             case 'ANY_SUBLINK':
                 if (node.testexpr && node.operName) {
                     const testExpr = this.visit(node.testexpr, context);
-                    const operator = this.deparseOperatorName(node.operName);
+                    const operator = this.deparseOperatorName(node.operName, context);
                     return `${testExpr} ${operator} ANY ${subselect}`;
                 }
                 else if (node.testexpr) {
@@ -2543,7 +2791,7 @@ class Deparser {
             case 'ALL_SUBLINK':
                 if (node.testexpr && node.operName) {
                     const testExpr = this.visit(node.testexpr, context);
-                    const operator = this.deparseOperatorName(node.operName);
+                    const operator = this.deparseOperatorName(node.operName, context);
                     return `${testExpr} ${operator} ALL ${subselect}`;
                 }
                 return subselect;
@@ -2585,7 +2833,7 @@ class Deparser {
         }
         // Only add frame clause if frameOptions indicates non-default framing
         if (node.frameOptions && node.frameOptions !== 1058) {
-            const frameClause = this.formatWindowFrame(node);
+            const frameClause = this.formatWindowFrame(node, context.spawn('WindowDef'));
             if (frameClause) {
                 windowParts.push(frameClause);
             }
@@ -2605,7 +2853,7 @@ class Deparser {
         }
         return output.join(' ');
     }
-    formatWindowFrame(node) {
+    formatWindowFrame(node, context) {
         if (!node.frameOptions)
             return null;
         const frameOptions = node.frameOptions;
@@ -2614,7 +2862,7 @@ class Deparser {
             if (frameOptions & 0x02) { // FRAMEOPTION_RANGE
                 frameParts.push('RANGE');
             }
-            else if (frameOptions & 0x04) { // FRAMEOPTION_ROWS  
+            else if (frameOptions & 0x04) { // FRAMEOPTION_ROWS
                 frameParts.push('ROWS');
             }
             else if (frameOptions & 0x08) { // FRAMEOPTION_GROUPS
@@ -2635,8 +2883,8 @@ class Deparser {
         }
         else if (frameOptions === 18453) {
             if (node.startOffset && node.endOffset) {
-                boundsParts.push(`${this.visit(node.startOffset, { parentNodeTypes: [] })} PRECEDING`);
-                boundsParts.push(`AND ${this.visit(node.endOffset, { parentNodeTypes: [] })} FOLLOWING`);
+                boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
+                boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
             }
         }
         else if (frameOptions === 1557) {
@@ -2646,7 +2894,7 @@ class Deparser {
         else if (frameOptions === 16917) {
             boundsParts.push('CURRENT ROW');
             if (node.endOffset) {
-                boundsParts.push(`AND ${this.visit(node.endOffset, { parentNodeTypes: [] })} FOLLOWING`);
+                boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
             }
         }
         else if (frameOptions === 1058) {
@@ -2656,13 +2904,13 @@ class Deparser {
             // 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, { parentNodeTypes: [] })} PRECEDING`);
+                    boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
                 }
                 else if (frameOptions & 0x800) { // FRAMEOPTION_START_VALUE_FOLLOWING
-                    boundsParts.push(`${this.visit(node.startOffset, { parentNodeTypes: [] })} FOLLOWING`);
+                    boundsParts.push(`${this.visit(node.startOffset, context)} FOLLOWING`);
                 }
                 else {
-                    boundsParts.push(`${this.visit(node.startOffset, { parentNodeTypes: [] })} PRECEDING`);
+                    boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
                 }
             }
             else if (frameOptions & 0x10) { // FRAMEOPTION_START_UNBOUNDED_PRECEDING
@@ -2675,13 +2923,13 @@ class Deparser {
             if (node.endOffset) {
                 if (boundsParts.length > 0) {
                     if (frameOptions & 0x1000) { // FRAMEOPTION_END_VALUE_PRECEDING
-                        boundsParts.push(`AND ${this.visit(node.endOffset, { parentNodeTypes: [] })} 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, { parentNodeTypes: [] })} FOLLOWING`);
+                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
                     }
                     else {
-                        boundsParts.push(`AND ${this.visit(node.endOffset, { parentNodeTypes: [] })} FOLLOWING`);
+                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
                     }
                 }
             }
@@ -2766,7 +3014,7 @@ class Deparser {
             const colnames = list_utils_1.ListUtils.unwrapList(node.aliascolnames);
             const colnameStrs = colnames.map(col => this.visit(col, context));
             // Don't add space before column list parentheses to match original formatting
-            output[output.length - 1] += this.formatter.parens(colnameStrs.join(', '));
+            output[output.length - 1] += context.parens(colnameStrs.join(', '));
         }
         output.push('AS');
         // Handle materialization clauses
@@ -2777,7 +3025,7 @@ class Deparser {
             output.push('MATERIALIZED');
         }
         if (node.ctequery) {
-            output.push(this.formatter.parens(this.visit(node.ctequery, context)));
+            output.push(context.parens(this.visit(node.ctequery, context)));
         }
         return output.join(' ');
     }
@@ -2853,7 +3101,7 @@ class Deparser {
     DistinctExpr(node, context) {
         const args = list_utils_1.ListUtils.unwrapList(node.args);
         if (args.length === 2) {
-            const literalContext = { ...context, isStringLiteral: true };
+            const literalContext = context.spawn('DistinctExpr', { isStringLiteral: true });
             const left = this.visit(args[0], literalContext);
             const right = this.visit(args[1], literalContext);
             return `${left} IS DISTINCT FROM ${right}`;
@@ -2863,7 +3111,7 @@ class Deparser {
     NullIfExpr(node, context) {
         const args = list_utils_1.ListUtils.unwrapList(node.args);
         if (args.length === 2) {
-            const literalContext = { ...context, isStringLiteral: true };
+            const literalContext = context.spawn('NullIfExpr', { isStringLiteral: true });
             const left = this.visit(args[0], literalContext);
             const right = this.visit(args[1], literalContext);
             return `NULLIF(${left}, ${right})`;
@@ -2942,7 +3190,7 @@ class Deparser {
     }
     RelabelType(node, context) {
         if (node.arg) {
-            const literalContext = { ...context, isStringLiteral: true };
+            const literalContext = context.spawn('RelabelType', { isStringLiteral: true });
             return this.visit(node.arg, literalContext);
         }
         return '';
@@ -2961,7 +3209,7 @@ class Deparser {
     }
     ConvertRowtypeExpr(node, context) {
         if (node.arg) {
-            const literalContext = { ...context, isStringLiteral: true };
+            const literalContext = context.spawn('ConvertRowtypeExpr', { isStringLiteral: true });
             return this.visit(node.arg, literalContext);
         }
         return '';
@@ -2992,10 +3240,10 @@ class Deparser {
         }
         if (node.aliases && node.aliases.length > 0) {
             const aliasStrs = list_utils_1.ListUtils.unwrapList(node.aliases).map(alias => this.visit(alias, context));
-            output.push(this.formatter.parens(aliasStrs.join(', ')));
+            output.push(context.parens(aliasStrs.join(', ')));
         }
         if (node.options && node.options.length > 0) {
-            const viewContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'ViewStmt'] };
+            const viewContext = context.spawn('ViewStmt');
             const optionStrs = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, viewContext));
             output.push(`WITH (${optionStrs.join(', ')})`);
@@ -3042,22 +3290,22 @@ class Deparser {
         }
         if (node.indexParams && node.indexParams.length > 0) {
             const paramStrs = list_utils_1.ListUtils.unwrapList(node.indexParams).map(param => this.visit(param, context));
-            output.push(this.formatter.parens(paramStrs.join(', ')));
+            output.push(context.parens(paramStrs.join(', ')));
         }
         if (node.indexIncludingParams && node.indexIncludingParams.length > 0) {
             const includeStrs = list_utils_1.ListUtils.unwrapList(node.indexIncludingParams).map(param => this.visit(param, context));
             output.push('INCLUDE');
-            output.push(this.formatter.parens(includeStrs.join(', ')));
+            output.push(context.parens(includeStrs.join(', ')));
         }
         if (node.whereClause) {
             output.push('WHERE');
             output.push(this.visit(node.whereClause, context));
         }
         if (node.options && node.options.length > 0) {
-            const indexContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'IndexStmt'] };
+            const indexContext = context.spawn('IndexStmt');
             const optionStrs = list_utils_1.ListUtils.unwrapList(node.options).map(option => this.visit(option, indexContext));
             output.push('WITH');
-            output.push(this.formatter.parens(optionStrs.join(', ')));
+            output.push(context.parens(optionStrs.join(', ')));
         }
         if (node.nulls_not_distinct) {
             output.push('NULLS NOT DISTINCT');
@@ -3074,7 +3322,7 @@ class Deparser {
             output.push(quote_utils_1.QuoteUtils.quote(node.name));
         }
         else if (node.expr) {
-            output.push(this.formatter.parens(this.visit(node.expr, context)));
+            output.push(context.parens(this.visit(node.expr, context)));
         }
         if (node.collation && node.collation.length > 0) {
             const collationStrs = list_utils_1.ListUtils.unwrapList(node.collation).map(coll => this.visit(coll, context));
@@ -3091,7 +3339,7 @@ class Deparser {
                         const stringData = this.getNodeData(opt.DefElem.arg);
                         return `${opt.DefElem.defname}='${stringData.sval}'`;
                     }
-                    return this.visit(opt, context);
+                    return this.visit(opt, context.spawn('IndexElem'));
                 });
                 opclassStr += `(${opclassOpts.join(', ')})`;
             }
@@ -3125,7 +3373,7 @@ class Deparser {
             output.push(quote_utils_1.QuoteUtils.quote(node.name));
         }
         else if (node.expr) {
-            output.push(this.formatter.parens(this.visit(node.expr, context)));
+            output.push(context.parens(this.visit(node.expr, context)));
         }
         if (node.collation && node.collation.length > 0) {
             const collationStrs = list_utils_1.ListUtils.unwrapList(node.collation).map(coll => this.visit(coll, context));
@@ -3273,16 +3521,16 @@ class Deparser {
             if (node.rarg && 'JoinExpr' in node.rarg && !node.rarg.JoinExpr.alias) {
                 rargStr = `(${rargStr})`;
             }
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + joinStr + ' ' + rargStr);
+            if (context.isPretty()) {
+                output.push(context.newline() + joinStr + ' ' + rargStr);
             }
             else {
                 output.push(joinStr + ' ' + rargStr);
             }
         }
         else {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + joinStr);
+            if (context.isPretty()) {
+                output.push(context.newline() + joinStr);
             }
             else {
                 output.push(joinStr);
@@ -3291,7 +3539,7 @@ class Deparser {
         if (node.usingClause && node.usingClause.length > 0) {
             const usingList = list_utils_1.ListUtils.unwrapList(node.usingClause);
             const columnNames = usingList.map(col => this.visit(col, context));
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 output.push(` USING (${columnNames.join(', ')})`);
             }
             else {
@@ -3300,14 +3548,14 @@ class Deparser {
         }
         else if (node.quals) {
             const qualsStr = this.visit(node.quals, context);
-            if (this.formatter.isPretty()) {
+            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${this.formatter.newline()}${this.formatter.indent(qualsStr)}`);
+                        output.push(` ON${context.newline()}${context.indent(qualsStr)}`);
                     }
                 }
                 else {
@@ -3319,7 +3567,7 @@ class Deparser {
             }
         }
         let result;
-        if (this.formatter.isPretty()) {
+        if (context.isPretty()) {
             result = output.join('');
         }
         else {
@@ -3426,8 +3674,8 @@ class Deparser {
                             else if (nodeData.sval !== undefined) {
                                 // Handle nested sval structure: { sval: { sval: "value" } }
                                 const svalValue = typeof nodeData.sval === 'object' ? nodeData.sval.sval : nodeData.sval;
-                                const stringValue = svalValue.replace(/'/g, '').toLowerCase();
-                                boolValue = stringValue === 'on' || stringValue === 'true';
+                                const stringValue = svalValue.replace(/'/g, '');
+                                boolValue = stringValue.toLowerCase() === 'on' || stringValue.toLowerCase() === 'true';
                             }
                         }
                         return boolValue ? 'READ ONLY' : 'READ WRITE';
@@ -3450,8 +3698,8 @@ class Deparser {
                             else if (nodeData.sval !== undefined) {
                                 // Handle nested sval structure: { sval: { sval: "value" } }
                                 const svalValue = typeof nodeData.sval === 'object' ? nodeData.sval.sval : nodeData.sval;
-                                const stringValue = svalValue.replace(/'/g, '').toLowerCase();
-                                boolValue = stringValue === 'on' || stringValue === 'true';
+                                const stringValue = svalValue.replace(/'/g, '');
+                                boolValue = stringValue.toLowerCase() === 'on' || stringValue.toLowerCase() === 'true';
                             }
                         }
                         return boolValue ? 'DEFERRABLE' : 'NOT DEFERRABLE';
@@ -3518,8 +3766,8 @@ class Deparser {
                                         else if (nodeData.sval !== undefined) {
                                             // Handle nested sval structure: { sval: { sval: "value" } }
                                             const svalValue = typeof nodeData.sval === 'object' ? nodeData.sval.sval : nodeData.sval;
-                                            const stringValue = svalValue.replace(/'/g, '').toLowerCase();
-                                            boolValue = stringValue === 'on' || stringValue === 'true';
+                                            const stringValue = svalValue.replace(/'/g, '');
+                                            boolValue = stringValue.toLowerCase() === 'on' || stringValue.toLowerCase() === 'true';
                                         }
                                     }
                                     transactionOptions.push(boolValue ? 'READ ONLY' : 'READ WRITE');
@@ -3537,8 +3785,8 @@ class Deparser {
                                         else if (nodeData.sval !== undefined) {
                                             // Handle nested sval structure: { sval: { sval: "value" } }
                                             const svalValue = typeof nodeData.sval === 'object' ? nodeData.sval.sval : nodeData.sval;
-                                            const stringValue = svalValue.replace(/'/g, '').toLowerCase();
-                                            boolValue = stringValue === 'on' || stringValue === 'true';
+                                            const stringValue = svalValue.replace(/'/g, '');
+                                            boolValue = stringValue.toLowerCase() === 'on' || stringValue.toLowerCase() === 'true';
                                         }
                                     }
                                     transactionOptions.push(boolValue ? 'DEFERRABLE' : 'NOT DEFERRABLE');
@@ -3604,7 +3852,7 @@ class Deparser {
         }
         switch (node.roletype) {
             case 'ROLESPEC_PUBLIC':
-                return 'public';
+                return 'PUBLIC';
             case 'ROLESPEC_CURRENT_USER':
                 return 'CURRENT_USER';
             case 'ROLESPEC_SESSION_USER':
@@ -3612,7 +3860,7 @@ class Deparser {
             case 'ROLESPEC_CURRENT_ROLE':
                 return 'CURRENT_ROLE';
             default:
-                return 'public';
+                return 'PUBLIC';
         }
     }
     roletype(node, context) {
@@ -3922,7 +4170,7 @@ class Deparser {
                         }).filter((name) => name && name.trim());
                         return items.join('.');
                     }
-                    const objContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DropStmt'], objtype: node.removeType };
+                    const objContext = context.spawn('DropStmt', { objtype: node.removeType });
                     const objName = this.visit(objList, objContext);
                     return objName;
                 }).filter((name) => name && name.trim()).join(', ');
@@ -4022,7 +4270,7 @@ class Deparser {
         if (node.options && node.options.length > 0) {
             output.push('WITH');
             const optionsStr = list_utils_1.ListUtils.unwrapList(node.options)
-                .map(opt => this.visit(opt, context))
+                .map(opt => this.visit(opt, context.spawn('CopyStmt')))
                 .join(', ');
             output.push(`(${optionsStr})`);
         }
@@ -4068,18 +4316,31 @@ class Deparser {
         if (node.missing_ok) {
             output.push('IF EXISTS');
         }
-        const alterContext = node.objtype === 'OBJECT_TYPE'
-            ? { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterTypeStmt'] }
-            : context;
+        const alterContext = context.spawn('AlterTableStmt', { objtype: node.objtype });
         if (node.relation) {
             const relationStr = this.RangeVar(node.relation, alterContext);
             output.push(relationStr);
         }
         if (node.cmds && node.cmds.length > 0) {
-            const commandsStr = list_utils_1.ListUtils.unwrapList(node.cmds)
-                .map(cmd => this.visit(cmd, alterContext))
-                .join(', ');
-            output.push(commandsStr);
+            const commands = list_utils_1.ListUtils.unwrapList(node.cmds);
+            if (context.isPretty()) {
+                const commandsStr = commands
+                    .map(cmd => {
+                    const cmdStr = this.visit(cmd, alterContext);
+                    if (cmdStr.startsWith('ADD CONSTRAINT') || cmdStr.startsWith('ADD ')) {
+                        return context.newline() + context.indent(cmdStr);
+                    }
+                    return cmdStr;
+                })
+                    .join(',');
+                output.push(commandsStr);
+            }
+            else {
+                const commandsStr = commands
+                    .map(cmd => this.visit(cmd, alterContext))
+                    .join(', ');
+                output.push(commandsStr);
+            }
         }
         return output.join(' ');
     }
@@ -4088,7 +4349,7 @@ class Deparser {
         if (node.subtype) {
             switch (node.subtype) {
                 case 'AT_AddColumn':
-                    if (context.parentNodeTypes.includes('AlterTypeStmt')) {
+                    if (context.objtype === 'OBJECT_TYPE') {
                         output.push('ADD ATTRIBUTE');
                     }
                     else {
@@ -4108,14 +4369,14 @@ class Deparser {
                         }
                         if (colDefData.fdwoptions && colDefData.fdwoptions.length > 0) {
                             parts.push('OPTIONS');
-                            const columnContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'ColumnDef'] };
+                            const columnContext = context.spawn('ColumnDef');
                             const options = list_utils_1.ListUtils.unwrapList(colDefData.fdwoptions).map(opt => this.visit(opt, columnContext));
                             parts.push(`(${options.join(', ')})`);
                         }
                         if (colDefData.constraints) {
                             const constraints = list_utils_1.ListUtils.unwrapList(colDefData.constraints);
                             const constraintStrs = constraints.map(constraint => {
-                                const columnConstraintContext = { ...context, isColumnConstraint: true };
+                                const columnConstraintContext = context.spawn('ColumnDef', { isColumnConstraint: true });
                                 return this.visit(constraint, columnConstraintContext);
                             });
                             parts.push(...constraintStrs);
@@ -4135,7 +4396,7 @@ class Deparser {
                     break;
                 case 'AT_DropColumn':
                     if (node.missing_ok) {
-                        if (context.parentNodeTypes.includes('AlterTypeStmt')) {
+                        if (context.objtype === 'OBJECT_TYPE') {
                             output.push('DROP ATTRIBUTE IF EXISTS');
                         }
                         else {
@@ -4143,7 +4404,7 @@ class Deparser {
                         }
                     }
                     else {
-                        if (context.parentNodeTypes.includes('AlterTypeStmt')) {
+                        if (context.objtype === 'OBJECT_TYPE') {
                             output.push('DROP ATTRIBUTE');
                         }
                         else {
@@ -4161,7 +4422,7 @@ class Deparser {
                     }
                     break;
                 case 'AT_AlterColumnType':
-                    if (context.parentNodeTypes.includes('AlterTypeStmt')) {
+                    if (context.objtype === 'OBJECT_TYPE') {
                         output.push('ALTER ATTRIBUTE');
                     }
                     else {
@@ -4225,7 +4486,7 @@ class Deparser {
                 case 'AT_SetRelOptions':
                     output.push('SET');
                     if (node.def) {
-                        const alterTableContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterTableCmd'], subtype: 'AT_SetRelOptions' };
+                        const alterTableContext = context.spawn('AlterTableCmd', { subtype: 'AT_SetRelOptions' });
                         const options = list_utils_1.ListUtils.unwrapList(node.def)
                             .map(option => this.visit(option, alterTableContext))
                             .join(', ');
@@ -4238,7 +4499,7 @@ class Deparser {
                 case 'AT_ResetRelOptions':
                     output.push('RESET');
                     if (node.def) {
-                        const alterTableContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterTableCmd'], subtype: 'AT_ResetRelOptions' };
+                        const alterTableContext = context.spawn('AlterTableCmd', { subtype: 'AT_ResetRelOptions' });
                         const options = list_utils_1.ListUtils.unwrapList(node.def)
                             .map(option => this.visit(option, alterTableContext))
                             .join(', ');
@@ -4333,7 +4594,7 @@ class Deparser {
                     }
                     output.push('SET');
                     if (node.def) {
-                        const alterTableContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterTableCmd'], subtype: 'AT_SetOptions' };
+                        const alterTableContext = context.spawn('AlterTableCmd', { subtype: 'AT_SetOptions' });
                         const options = list_utils_1.ListUtils.unwrapList(node.def)
                             .map(option => this.visit(option, alterTableContext))
                             .join(', ');
@@ -4350,7 +4611,7 @@ class Deparser {
                     }
                     output.push('RESET');
                     if (node.def) {
-                        const alterTableContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterTableCmd'], subtype: 'AT_ResetOptions' };
+                        const alterTableContext = context.spawn('AlterTableCmd', { subtype: 'AT_ResetOptions' });
                         const options = list_utils_1.ListUtils.unwrapList(node.def)
                             .map(option => this.visit(option, alterTableContext))
                             .join(', ');
@@ -4591,7 +4852,7 @@ class Deparser {
                     }
                     output.push('OPTIONS');
                     if (node.def) {
-                        const alterColumnContext = { ...context, alterColumnOptions: true };
+                        const alterColumnContext = context.spawn('AlterTableCmd', { alterColumnOptions: true });
                         const options = list_utils_1.ListUtils.unwrapList(node.def)
                             .map(option => this.visit(option, alterColumnContext))
                             .join(', ');
@@ -4631,7 +4892,7 @@ class Deparser {
                 case 'AT_GenericOptions':
                     output.push('OPTIONS');
                     if (node.def) {
-                        const alterTableContext = { ...context, alterTableOptions: true };
+                        const alterTableContext = context.spawn('AlterTableCmd', { alterTableOptions: true });
                         const options = list_utils_1.ListUtils.unwrapList(node.def)
                             .map(option => this.visit(option, alterTableContext))
                             .join(', ');
@@ -4735,7 +4996,7 @@ class Deparser {
             output.push(this.TypeName(node.returnType, context));
         }
         if (node.options && node.options.length > 0) {
-            const funcContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateFunctionStmt'] };
+            const funcContext = context.spawn('CreateFunctionStmt');
             const options = node.options.map((opt) => this.visit(opt, funcContext));
             output.push(...options);
         }
@@ -4822,7 +5083,7 @@ class Deparser {
         }
         output.push('AS', 'ENUM');
         if (node.vals && node.vals.length > 0) {
-            const enumContext = { ...context, isEnumValue: true };
+            const enumContext = context.spawn('CreateEnumStmt', { isEnumValue: true });
             const values = list_utils_1.ListUtils.unwrapList(node.vals)
                 .map(val => this.visit(val, enumContext))
                 .join(', ');
@@ -4877,9 +5138,8 @@ class Deparser {
             output.push(roleName);
         }
         if (node.options) {
-            const roleContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateRoleStmt'] };
             const options = list_utils_1.ListUtils.unwrapList(node.options)
-                .map(option => this.visit(option, roleContext))
+                .map(option => this.visit(option, context.spawn('CreateRoleStmt')))
                 .join(' ');
             if (options) {
                 output.push('WITH');
@@ -4910,7 +5170,7 @@ class Deparser {
                 const stringData = this.getNodeData(node.arg);
                 return `${node.defname}='${stringData.sval}'`;
             }
-            return `${node.defname}=${this.visit(node.arg, { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefElem'] })}`;
+            return `${node.defname}=${this.visit(node.arg, context.spawn('DefElem'))}`;
         }
         // Handle CREATE OPERATOR boolean flags - MUST be first to preserve case
         if (context.parentNodeTypes.includes('DefineStmt') &&
@@ -4926,13 +5186,13 @@ class Deparser {
                 if (!node.arg) {
                     return `NO ${node.defname.toUpperCase()}`;
                 }
-                const defElemContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefElem'] };
+                const defElemContext = context.spawn('DefElem');
                 const argValue = this.visit(node.arg, defElemContext);
                 return `${node.defname.toUpperCase()} ${argValue}`;
             }
             // Handle OPTIONS clause - use space format, not equals format
             if (node.arg) {
-                const defElemContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefElem'] };
+                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("'")
@@ -4986,7 +5246,7 @@ class Deparser {
                 if (!node.arg) {
                     return 'PASSWORD NULL';
                 }
-                const defElemContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefElem'] };
+                const defElemContext = context.spawn('DefElem');
                 const argValue = this.visit(node.arg, defElemContext);
                 const quotedValue = typeof argValue === 'string' && !argValue.startsWith("'")
                     ? `'${argValue}'`
@@ -4995,7 +5255,7 @@ class Deparser {
             }
         }
         if (node.arg) {
-            const defElemContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefElem'] };
+            const defElemContext = context.spawn('DefElem');
             const argValue = this.visit(node.arg, defElemContext);
             if (context.parentNodeTypes.includes('AlterOperatorStmt')) {
                 if (node.arg && this.getNodeType(node.arg) === 'TypeName') {
@@ -5071,7 +5331,7 @@ class Deparser {
                 if (node.defname === 'sysid') {
                     return `SYSID ${argValue}`;
                 }
-                if (argValue === 'true') {
+                if (String(argValue) === 'true') {
                     // Handle special cases where the positive form has a different name
                     if (node.defname === 'isreplication') {
                         return 'REPLICATION';
@@ -5081,7 +5341,7 @@ class Deparser {
                     }
                     return node.defname.toUpperCase();
                 }
-                else if (argValue === 'false') {
+                else if (String(argValue) === 'false') {
                     // Handle special cases where the negative form has a different name
                     if (node.defname === 'canlogin') {
                         return 'NOLOGIN';
@@ -5145,7 +5405,7 @@ class Deparser {
             }
             if (context.parentNodeTypes.includes('DoStmt')) {
                 if (node.defname === 'as') {
-                    const defElemContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefElem'] };
+                    const defElemContext = context.spawn('DefElem');
                     const argValue = node.arg ? this.visit(node.arg, defElemContext) : '';
                     if (Array.isArray(argValue)) {
                         const bodyParts = argValue;
@@ -5436,7 +5696,7 @@ class Deparser {
         }
         if (node.options && node.options.length > 0) {
             output.push('WITH');
-            const tsContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateTableSpaceStmt'] };
+            const tsContext = context.spawn('CreateTableSpaceStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, tsContext))
                 .join(', ');
@@ -5466,7 +5726,7 @@ class Deparser {
             output.push('SET');
         }
         if (node.options && node.options.length > 0) {
-            const tablespaceContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterTableSpaceOptionsStmt'] };
+            const tablespaceContext = context.spawn('AlterTableSpaceOptionsStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, tablespaceContext))
                 .join(', ');
@@ -5483,7 +5743,7 @@ class Deparser {
             output.push(this.quoteIfNeeded(node.extname));
         }
         if (node.options && node.options.length > 0) {
-            const extContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateExtensionStmt'] };
+            const extContext = context.spawn('CreateExtensionStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, extContext))
                 .join(' ');
@@ -5497,7 +5757,7 @@ class Deparser {
             output.push(this.quoteIfNeeded(node.extname));
         }
         if (node.options && node.options.length > 0) {
-            const extContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterExtensionStmt'] };
+            const extContext = context.spawn('AlterExtensionStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, extContext))
                 .join(' ');
@@ -5511,7 +5771,7 @@ class Deparser {
             output.push(node.fdwname);
         }
         if (node.func_options && node.func_options.length > 0) {
-            const fdwContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateFdwStmt'] };
+            const fdwContext = context.spawn('CreateFdwStmt');
             const funcOptions = list_utils_1.ListUtils.unwrapList(node.func_options)
                 .map(option => this.visit(option, fdwContext))
                 .join(' ');
@@ -5519,7 +5779,7 @@ class Deparser {
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
-            const fdwContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateFdwStmt'] };
+            const fdwContext = context.spawn('CreateFdwStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options)
                 .map(option => this.visit(option, fdwContext))
                 .join(', ');
@@ -5621,7 +5881,7 @@ class Deparser {
                     output.push('ADD');
                     if (node.def) {
                         // Pass domain context to avoid adding constraint names for domain constraints
-                        const domainContext = { ...context, isDomainConstraint: true };
+                        const domainContext = context.spawn('CreateDomainStmt', { isDomainConstraint: true });
                         output.push(this.visit(node.def, domainContext));
                     }
                     break;
@@ -5647,7 +5907,7 @@ class Deparser {
                     output.push('ADD');
                     if (node.def) {
                         // Pass domain context to avoid adding constraint names for domain constraints
-                        const domainContext = { ...context, isDomainConstraint: true };
+                        const domainContext = context.spawn('CreateDomainStmt', { isDomainConstraint: true });
                         output.push(this.visit(node.def, domainContext));
                     }
                     break;
@@ -6009,7 +6269,7 @@ class Deparser {
                 output.push(`${operatorName}(${args.join(', ')})`);
             }
             else {
-                const objContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CommentStmt'], objtype: node.objtype };
+                const objContext = context.spawn('CommentStmt', { objtype: node.objtype });
                 output.push(this.visit(node.object, objContext));
             }
         }
@@ -6055,13 +6315,13 @@ class Deparser {
         const output = [];
         const initialParts = ['CREATE', 'POLICY'];
         if (node.policy_name) {
-            initialParts.push(`"${node.policy_name}"`);
+            initialParts.push(quote_utils_1.QuoteUtils.quote(node.policy_name));
         }
         output.push(initialParts.join(' '));
         // Add ON clause on new line in pretty mode
         if (node.table) {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent(`ON ${this.RangeVar(node.table, context)}`));
+            if (context.isPretty()) {
+                output.push(context.newline() + context.indent(`ON ${this.RangeVar(node.table, context)}`));
             }
             else {
                 output.push('ON');
@@ -6070,24 +6330,24 @@ class Deparser {
         }
         // Handle AS RESTRICTIVE/PERMISSIVE clause
         if (node.permissive === undefined) {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent('AS RESTRICTIVE'));
+            if (context.isPretty()) {
+                output.push(context.newline() + context.indent('AS RESTRICTIVE'));
             }
             else {
                 output.push('AS', 'RESTRICTIVE');
             }
         }
         else if (node.permissive === true) {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent('AS PERMISSIVE'));
+            if (context.isPretty()) {
+                output.push(context.newline() + context.indent('AS PERMISSIVE'));
             }
             else {
                 output.push('AS', 'PERMISSIVE');
             }
         }
         if (node.cmd_name) {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent(`FOR ${node.cmd_name.toUpperCase()}`));
+            if (context.isPretty()) {
+                output.push(context.newline() + context.indent(`FOR ${node.cmd_name.toUpperCase()}`));
             }
             else {
                 output.push('FOR', node.cmd_name.toUpperCase());
@@ -6095,8 +6355,8 @@ class Deparser {
         }
         if (node.roles && node.roles.length > 0) {
             const roles = list_utils_1.ListUtils.unwrapList(node.roles).map(role => this.visit(role, context));
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent(`TO ${roles.join(', ')}`));
+            if (context.isPretty()) {
+                output.push(context.newline() + context.indent(`TO ${roles.join(', ')}`));
             }
             else {
                 output.push('TO');
@@ -6104,11 +6364,11 @@ class Deparser {
             }
         }
         if (node.qual) {
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 const qualExpr = this.visit(node.qual, context);
-                output.push(this.formatter.newline() + this.formatter.indent('USING ('));
-                output.push(this.formatter.newline() + this.formatter.indent(this.formatter.indent(qualExpr)));
-                output.push(this.formatter.newline() + this.formatter.indent(')'));
+                output.push(context.newline() + context.indent('USING ('));
+                output.push(context.newline() + context.indent(context.indent(qualExpr)));
+                output.push(context.newline() + context.indent(')'));
             }
             else {
                 output.push('USING');
@@ -6116,23 +6376,23 @@ class Deparser {
             }
         }
         if (node.with_check) {
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 const checkExpr = this.visit(node.with_check, context);
-                output.push(this.formatter.newline() + this.formatter.indent('WITH CHECK ('));
-                output.push(this.formatter.newline() + this.formatter.indent(this.formatter.indent(checkExpr)));
-                output.push(this.formatter.newline() + this.formatter.indent(')'));
+                output.push(context.newline() + context.indent('WITH CHECK ('));
+                output.push(context.newline() + context.indent(context.indent(checkExpr)));
+                output.push(context.newline() + context.indent(')'));
             }
             else {
                 output.push('WITH CHECK');
                 output.push(`(${this.visit(node.with_check, context)})`);
             }
         }
-        return this.formatter.isPretty() ? output.join('') : output.join(' ');
+        return context.isPretty() ? output.join('') : output.join(' ');
     }
     AlterPolicyStmt(node, context) {
         const output = ['ALTER', 'POLICY'];
         if (node.policy_name) {
-            output.push(`"${node.policy_name}"`);
+            output.push(quote_utils_1.QuoteUtils.quote(node.policy_name));
         }
         if (node.table) {
             output.push('ON');
@@ -6172,7 +6432,7 @@ class Deparser {
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
-            const userMappingContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateUserMappingStmt'] };
+            const userMappingContext = context.spawn('CreateUserMappingStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, userMappingContext));
             output.push(`(${options.join(', ')})`);
         }
@@ -6355,7 +6615,7 @@ class Deparser {
     DoStmt(node, context) {
         const output = ['DO'];
         if (node.args && node.args.length > 0) {
-            const doContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DoStmt'] };
+            const doContext = context.spawn('DoStmt');
             const args = list_utils_1.ListUtils.unwrapList(node.args);
             const processedArgs = [];
             for (const arg of args) {
@@ -6660,7 +6920,7 @@ class Deparser {
     ObjectWithArgs(node, context) {
         let result = '';
         if (node.objname && node.objname.length > 0) {
-            const objContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'ObjectWithArgs'] };
+            const objContext = context.spawn('ObjectWithArgs');
             const names = list_utils_1.ListUtils.unwrapList(node.objname).map(name => this.visit(name, objContext));
             result = names.join('.');
         }
@@ -6702,7 +6962,7 @@ class Deparser {
         }
         output.push('SET');
         if (node.options && node.options.length > 0) {
-            const alterOpContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterOperatorStmt'] };
+            const alterOpContext = context.spawn('AlterOperatorStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, alterOpContext));
             output.push(`(${options.join(', ')})`);
         }
@@ -6714,13 +6974,13 @@ class Deparser {
             output.push(quote_utils_1.QuoteUtils.quote(node.fdwname));
         }
         if (node.func_options && node.func_options.length > 0) {
-            const fdwContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterFdwStmt'] };
+            const fdwContext = context.spawn('AlterFdwStmt');
             const funcOptions = list_utils_1.ListUtils.unwrapList(node.func_options).map(opt => this.visit(opt, fdwContext));
             output.push(funcOptions.join(' '));
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
-            const fdwContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterFdwStmt'] };
+            const fdwContext = context.spawn('AlterFdwStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, fdwContext));
             output.push(`(${options.join(', ')})`);
         }
@@ -6746,7 +7006,7 @@ class Deparser {
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
             output.push('(');
-            const optionsContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateForeignServerStmt'] };
+            const optionsContext = context.spawn('CreateForeignServerStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, optionsContext));
             output.push(options.join(', '));
             output.push(')');
@@ -6764,7 +7024,7 @@ class Deparser {
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
             output.push('(');
-            const optionsContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterForeignServerStmt'] };
+            const optionsContext = context.spawn('AlterForeignServerStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, optionsContext));
             output.push(options.join(', '));
             output.push(')');
@@ -6785,7 +7045,7 @@ class Deparser {
         }
         if (node.options && node.options.length > 0) {
             output.push('OPTIONS');
-            const userMappingContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterUserMappingStmt'] };
+            const userMappingContext = context.spawn('AlterUserMappingStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, userMappingContext));
             output.push(`(${options.join(', ')})`);
         }
@@ -6845,7 +7105,7 @@ class Deparser {
             output.push(quote_utils_1.QuoteUtils.quote(node.local_schema));
         }
         if (node.options && node.options.length > 0) {
-            const importSchemaContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'ImportForeignSchemaStmt'] };
+            const importSchemaContext = context.spawn('ImportForeignSchemaStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, importSchemaContext));
             output.push(`OPTIONS (${options.join(', ')})`);
         }
@@ -6880,7 +7140,7 @@ class Deparser {
     ExplainStmt(node, context) {
         const output = ['EXPLAIN'];
         if (node.options && node.options.length > 0) {
-            const explainContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'ExplainStmt'] };
+            const explainContext = context.spawn('ExplainStmt');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(option => this.visit(option, explainContext));
             output.push(`(${options.join(', ')})`);
         }
@@ -7138,9 +7398,7 @@ class Deparser {
             output.push(this.RangeVar(node.relation, context));
         }
         else if (node.relation) {
-            const rangeVarContext = node.relationType === 'OBJECT_TYPE'
-                ? { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterTypeStmt'] }
-                : context;
+            const rangeVarContext = context.spawn('RenameStmt', { objtype: node.relationType });
             // Add ON keyword for policy operations
             if (node.renameType === 'OBJECT_POLICY') {
                 output.push('ON');
@@ -7322,7 +7580,7 @@ class Deparser {
             }
         }
         if (node.privileges && node.privileges.length > 0) {
-            const privilegeContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'GrantStmt'] };
+            const privilegeContext = context.spawn('GrantStmt');
             const privileges = list_utils_1.ListUtils.unwrapList(node.privileges)
                 .map(priv => this.visit(priv, privilegeContext))
                 .join(', ');
@@ -7630,7 +7888,12 @@ class Deparser {
         }
         if (node.action) {
             const actionStr = this.GrantStmt(node.action, context);
-            output.push(actionStr);
+            if (context.isPretty()) {
+                return output.join(' ') + context.newline() + context.indent(actionStr);
+            }
+            else {
+                output.push(actionStr);
+            }
         }
         return output.join(' ');
     }
@@ -7777,84 +8040,158 @@ class Deparser {
         if (node.trigname) {
             output.push(quote_utils_1.QuoteUtils.quote(node.trigname));
         }
-        const timing = [];
-        if (node.timing & 2)
-            timing.push('BEFORE');
-        else if (node.timing & 64)
-            timing.push('INSTEAD OF');
-        else
-            timing.push('AFTER'); // Default timing when no specific timing is set
-        output.push(timing.join(' '));
-        const events = [];
-        if (node.events & 4)
-            events.push('INSERT');
-        if (node.events & 8)
-            events.push('DELETE');
-        if (node.events & 16)
-            events.push('UPDATE');
-        if (node.events & 32)
-            events.push('TRUNCATE');
-        output.push(events.join(' OR '));
-        if (node.columns && node.columns.length > 0) {
-            output.push('OF');
-            const columnNames = list_utils_1.ListUtils.unwrapList(node.columns)
-                .map(col => this.visit(col, context))
-                .join(', ');
-            output.push(columnNames);
-        }
-        output.push('ON');
-        if (node.relation) {
-            output.push(this.RangeVar(node.relation, context));
-        }
-        if (node.constrrel) {
-            output.push('FROM');
-            output.push(this.RangeVar(node.constrrel, context));
-        }
-        if (node.deferrable) {
-            output.push('DEFERRABLE');
-        }
-        if (node.initdeferred) {
-            output.push('INITIALLY DEFERRED');
-        }
-        // Handle REFERENCING clauses
-        if (node.transitionRels && node.transitionRels.length > 0) {
-            output.push('REFERENCING');
-            const transitionClauses = list_utils_1.ListUtils.unwrapList(node.transitionRels)
-                .map(rel => this.visit(rel, context))
-                .join(' ');
-            output.push(transitionClauses);
-        }
-        if (node.row) {
-            output.push('FOR EACH ROW');
-        }
-        else {
-            output.push('FOR EACH STATEMENT');
-        }
-        if (node.whenClause) {
-            output.push('WHEN');
-            output.push('(');
-            output.push(this.visit(node.whenClause, context));
-            output.push(')');
-        }
-        output.push('EXECUTE');
-        if (node.funcname && node.funcname.length > 0) {
-            const funcName = list_utils_1.ListUtils.unwrapList(node.funcname)
-                .map(name => this.visit(name, context))
-                .join('.');
-            output.push('FUNCTION', funcName);
-        }
-        if (node.args && node.args.length > 0) {
-            output.push('(');
-            const args = list_utils_1.ListUtils.unwrapList(node.args)
-                .map(arg => this.visit(arg, context))
-                .join(', ');
-            output.push(args);
-            output.push(')');
+        if (context.isPretty()) {
+            const components = [];
+            const timing = [];
+            if (node.timing & 2)
+                timing.push('BEFORE');
+            else if (node.timing & 64)
+                timing.push('INSTEAD OF');
+            else
+                timing.push('AFTER');
+            const events = [];
+            if (node.events & 4)
+                events.push('INSERT');
+            if (node.events & 8)
+                events.push('DELETE');
+            if (node.events & 16) {
+                let updateStr = 'UPDATE';
+                if (node.columns && node.columns.length > 0) {
+                    const columnNames = list_utils_1.ListUtils.unwrapList(node.columns)
+                        .map(col => this.visit(col, context))
+                        .join(', ');
+                    updateStr += ' OF ' + columnNames;
+                }
+                events.push(updateStr);
+            }
+            if (node.events & 32)
+                events.push('TRUNCATE');
+            components.push(context.indent(timing.join(' ') + ' ' + events.join(' OR ')));
+            if (node.relation) {
+                components.push(context.indent('ON ' + this.RangeVar(node.relation, context)));
+            }
+            if (node.transitionRels && node.transitionRels.length > 0) {
+                const transitionClauses = list_utils_1.ListUtils.unwrapList(node.transitionRels)
+                    .map(rel => this.visit(rel, context))
+                    .join(' ');
+                components.push(context.indent('REFERENCING ' + transitionClauses));
+            }
+            if (node.deferrable) {
+                components.push(context.indent('DEFERRABLE'));
+            }
+            if (node.initdeferred) {
+                components.push(context.indent('INITIALLY DEFERRED'));
+            }
+            if (node.row) {
+                components.push(context.indent('FOR EACH ROW'));
+            }
+            else {
+                components.push(context.indent('FOR EACH STATEMENT'));
+            }
+            if (node.whenClause) {
+                const whenStr = 'WHEN (' + this.visit(node.whenClause, context) + ')';
+                components.push(context.indent(whenStr));
+            }
+            let executeStr = 'EXECUTE';
+            if (node.funcname && node.funcname.length > 0) {
+                const funcName = list_utils_1.ListUtils.unwrapList(node.funcname)
+                    .map(name => this.visit(name, context))
+                    .join('.');
+                executeStr += ' PROCEDURE ' + funcName;
+            }
+            if (node.args && node.args.length > 0) {
+                const argContext = context.spawn('CreateTrigStmt', { isStringLiteral: true });
+                const args = list_utils_1.ListUtils.unwrapList(node.args)
+                    .map(arg => this.visit(arg, argContext))
+                    .join(', ');
+                executeStr += '(' + args + ')';
+            }
+            else {
+                executeStr += '()';
+            }
+            components.push(context.indent(executeStr));
+            return output.join(' ') + context.newline() + components.join(context.newline());
         }
         else {
-            output.push('()');
+            const timing = [];
+            if (node.timing & 2)
+                timing.push('BEFORE');
+            else if (node.timing & 64)
+                timing.push('INSTEAD OF');
+            else
+                timing.push('AFTER');
+            output.push(timing.join(' '));
+            const events = [];
+            if (node.events & 4)
+                events.push('INSERT');
+            if (node.events & 8)
+                events.push('DELETE');
+            if (node.events & 16)
+                events.push('UPDATE');
+            if (node.events & 32)
+                events.push('TRUNCATE');
+            output.push(events.join(' OR '));
+            if (node.columns && node.columns.length > 0) {
+                output.push('OF');
+                const columnNames = list_utils_1.ListUtils.unwrapList(node.columns)
+                    .map(col => this.visit(col, context))
+                    .join(', ');
+                output.push(columnNames);
+            }
+            output.push('ON');
+            if (node.relation) {
+                output.push(this.RangeVar(node.relation, context));
+            }
+            if (node.constrrel) {
+                output.push('FROM');
+                output.push(this.RangeVar(node.constrrel, context));
+            }
+            if (node.deferrable) {
+                output.push('DEFERRABLE');
+            }
+            if (node.initdeferred) {
+                output.push('INITIALLY DEFERRED');
+            }
+            if (node.transitionRels && node.transitionRels.length > 0) {
+                output.push('REFERENCING');
+                const transitionClauses = list_utils_1.ListUtils.unwrapList(node.transitionRels)
+                    .map(rel => this.visit(rel, context))
+                    .join(' ');
+                output.push(transitionClauses);
+            }
+            if (node.row) {
+                output.push('FOR EACH ROW');
+            }
+            else {
+                output.push('FOR EACH STATEMENT');
+            }
+            if (node.whenClause) {
+                output.push('WHEN');
+                output.push('(');
+                output.push(this.visit(node.whenClause, context));
+                output.push(')');
+            }
+            output.push('EXECUTE');
+            if (node.funcname && node.funcname.length > 0) {
+                const funcName = list_utils_1.ListUtils.unwrapList(node.funcname)
+                    .map(name => this.visit(name, context))
+                    .join('.');
+                output.push('FUNCTION', funcName);
+            }
+            if (node.args && node.args.length > 0) {
+                output.push('(');
+                const argContext = context.spawn('CreateTrigStmt', { isStringLiteral: true });
+                const args = list_utils_1.ListUtils.unwrapList(node.args)
+                    .map(arg => this.visit(arg, argContext))
+                    .join(', ');
+                output.push(args);
+                output.push(')');
+            }
+            else {
+                output.push('()');
+            }
+            return output.join(' ');
         }
-        return output.join(' ');
     }
     TriggerTransition(node, context) {
         const output = [];
@@ -7880,7 +8217,7 @@ class Deparser {
         }
         if (node.whenclause && node.whenclause.length > 0) {
             output.push('WHEN');
-            const eventTriggerContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateEventTrigStmt'] };
+            const eventTriggerContext = context.spawn('CreateEventTrigStmt');
             const conditions = list_utils_1.ListUtils.unwrapList(node.whenclause)
                 .map(condition => this.visit(condition, eventTriggerContext))
                 .join(' AND ');
@@ -8069,7 +8406,7 @@ class Deparser {
             output.push(sequenceName.join('.'));
         }
         if (node.options && node.options.length > 0) {
-            const seqContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateSeqStmt'] };
+            const seqContext = context.spawn('CreateSeqStmt');
             const optionStrs = list_utils_1.ListUtils.unwrapList(node.options)
                 .filter(option => option != null && this.getNodeType(option) !== 'undefined')
                 .map(option => {
@@ -8106,7 +8443,7 @@ class Deparser {
             output.push(sequenceName.join('.'));
         }
         if (node.options && node.options.length > 0) {
-            const seqContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterSeqStmt'] };
+            const seqContext = context.spawn('AlterSeqStmt');
             const optionStrs = list_utils_1.ListUtils.unwrapList(node.options)
                 .filter(option => option && option !== undefined)
                 .map(option => {
@@ -8135,7 +8472,7 @@ class Deparser {
     CompositeTypeStmt(node, context) {
         const output = ['CREATE', 'TYPE'];
         if (node.typevar) {
-            const typeContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CompositeTypeStmt'] };
+            const typeContext = context.spawn('CompositeTypeStmt');
             output.push(this.RangeVar(node.typevar, typeContext));
         }
         output.push('AS');
@@ -8236,7 +8573,7 @@ class Deparser {
             output.push(this.RoleSpec(node.role, context));
         }
         if (node.options) {
-            const roleContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterRoleStmt'] };
+            const roleContext = context.spawn('AlterRoleStmt');
             // Handle GROUP operations specially based on action value
             if (isGroupStatement) {
                 const roleMembersOption = list_utils_1.ListUtils.unwrapList(node.options).find(option => option.DefElem && option.DefElem.defname === 'rolemembers');
@@ -8432,14 +8769,14 @@ class Deparser {
     AccessPriv(node, context) {
         const output = [];
         if (node.priv_name) {
-            output.push(node.priv_name);
+            output.push(node.priv_name.toUpperCase());
         }
         else {
             output.push('ALL');
         }
         if (node.cols && node.cols.length > 0) {
             output.push('(');
-            const colContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AccessPriv'] };
+            const colContext = context.spawn('AccessPriv');
             const columns = list_utils_1.ListUtils.unwrapList(node.cols).map(col => this.visit(col, colContext));
             output.push(columns.join(', '));
             output.push(')');
@@ -8519,7 +8856,7 @@ class Deparser {
                     output.push(list_utils_1.ListUtils.unwrapList(node.defnames).map(name => this.visit(name, context)).join('.'));
                 }
                 if (node.definition && node.definition.length > 0) {
-                    const defineStmtContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefineStmt'] };
+                    const defineStmtContext = context.spawn('DefineStmt');
                     const definitions = list_utils_1.ListUtils.unwrapList(node.definition).map(def => {
                         return this.visit(def, defineStmtContext);
                     });
@@ -9005,7 +9342,7 @@ class Deparser {
             const operatorNumber = node.number !== undefined ? node.number : 0;
             output.push(operatorNumber.toString());
             if (node.name) {
-                const opClassContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateOpClassItem'] };
+                const opClassContext = context.spawn('CreateOpClassItem');
                 output.push(this.ObjectWithArgs(node.name, opClassContext));
             }
         }
@@ -9015,7 +9352,7 @@ class Deparser {
             const functionNumber = node.number !== undefined ? node.number : 0;
             output.push(functionNumber.toString());
             if (node.name) {
-                const opClassContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateOpClassItem'] };
+                const opClassContext = context.spawn('CreateOpClassItem');
                 output.push(this.ObjectWithArgs(node.name, opClassContext));
             }
         }
@@ -9713,7 +10050,7 @@ class Deparser {
             output.push(this.ObjectWithArgs(node.func, context));
         }
         if (node.actions && node.actions.length > 0) {
-            const alterFunctionContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'AlterFunctionStmt'] };
+            const alterFunctionContext = context.spawn('AlterFunctionStmt');
             const actionStrs = list_utils_1.ListUtils.unwrapList(node.actions).map(action => this.visit(action, alterFunctionContext));
             output.push(actionStrs.join(' '));
         }
@@ -9957,7 +10294,7 @@ class Deparser {
     CreateForeignTableStmt(node, context) {
         const output = ['CREATE FOREIGN TABLE'];
         if (node.base && node.base.relation) {
-            const relationContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateForeignTableStmt'] };
+            const relationContext = context.spawn('CreateForeignTableStmt');
             // Handle relation node directly as RangeVar since it contains the RangeVar properties
             output.push(this.RangeVar(node.base.relation, relationContext));
         }
@@ -9987,7 +10324,7 @@ class Deparser {
             output.push(quote_utils_1.QuoteUtils.quote(node.servername));
         }
         if (node.options && node.options.length > 0) {
-            const foreignTableContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'CreateForeignTableStmt'] };
+            const foreignTableContext = context.spawn('CreateForeignTableStmt');
             const optionStrs = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, foreignTableContext));
             output.push(`OPTIONS (${optionStrs.join(', ')})`);
         }