pgsql-deparser 17.8.2 → 17.8.4

package/deparser.js

@@ -1,6 +1,7 @@
 "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");
@@ -103,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: '$$',
@@ -144,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
@@ -166,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();
         }
@@ -181,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) {
@@ -190,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}`);
@@ -220,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) {
@@ -240,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');
                 }
             }
@@ -260,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);
@@ -282,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);
@@ -294,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');
@@ -316,10 +321,10 @@ class Deparser {
         }
         if (node.targetList) {
             const targetList = list_utils_1.ListUtils.unwrapList(node.targetList);
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 if (targetList.length === 1) {
                     const targetNode = targetList[0];
-                    const target = this.visit(targetNode, { ...context, select: true });
+                    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);
@@ -327,7 +332,7 @@ class Deparser {
                             output.push(target);
                         }
                         else {
-                            output.push(this.formatter.indent(target));
+                            output.push(context.indent(target));
                         }
                     }
                     else {
@@ -337,20 +342,20 @@ class Deparser {
                 else {
                     const targetStrings = targetList
                         .map(e => {
-                        const targetStr = this.visit(e, { ...context, select: true });
+                        const targetStr = this.visit(e, context.spawn('SelectStmt', { select: true }));
                         if (this.containsMultilineStringLiteral(targetStr)) {
                             return targetStr;
                         }
-                        return this.formatter.indent(targetStr);
+                        return context.indent(targetStr);
                     });
-                    const formattedTargets = targetStrings.join(',' + this.formatter.newline());
+                    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);
             }
@@ -362,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');
@@ -385,17 +390,17 @@ class Deparser {
             }
         }
         if (node.valuesLists) {
-            if (this.formatter.isPretty()) {
+            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 this.formatter.parens(values.join(', '));
+                    return context.parens(values.join(', '));
                 });
                 const indentedTuples = lists.map(tuple => {
                     if (this.containsMultilineStringLiteral(tuple)) {
                         return tuple;
                     }
-                    return this.formatter.indent(tuple);
+                    return context.indent(tuple);
                 });
                 output.push(indentedTuples.join(',\n'));
             }
@@ -403,43 +408,43 @@ class Deparser {
                 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(', '));
+                    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 {
@@ -457,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);
             }
@@ -491,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(' ');
     }
@@ -505,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;
                         }
@@ -520,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;
                         }
@@ -534,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
@@ -580,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 &&
@@ -664,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)
@@ -704,7 +709,7 @@ class Deparser {
         }
         throw new Error(`Unhandled A_Expr kind: ${kind}`);
     }
-    deparseOperatorName(name) {
+    deparseOperatorName(name, context) {
         if (!name || name.length === 0) {
             return '';
         }
@@ -712,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('.')})`;
@@ -849,15 +854,15 @@ 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));
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 // Always format columns in multiline parentheses for pretty printing
-                const indentedColumns = columnNames.map(col => this.formatter.indent(col));
+                const indentedColumns = columnNames.map(col => context.indent(col));
                 output.push('(\n' + indentedColumns.join(',\n') + '\n)');
             }
             else {
-                output.push(this.formatter.parens(columnNames.join(', ')));
+                output.push(context.parens(columnNames.join(', ')));
             }
         }
         if (node.selectStmt) {
@@ -879,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) {
@@ -895,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(', '));
                     }
@@ -954,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);
                 }
             }
@@ -1051,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(''));
             }
@@ -1144,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 {
@@ -1159,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 {
@@ -1291,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}`;
@@ -1363,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(' ')})`;
@@ -1735,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));
@@ -1747,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');
         }
@@ -2007,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 {
@@ -2094,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':
@@ -2245,31 +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()) {
+            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 this.formatter.indent(trimmedEl.substring(1));
+                        return context.indent(trimmedEl.substring(1));
                     }
-                    return this.formatter.indent(trimmedEl);
-                }).join(',' + this.formatter.newline());
-                output.push('(' + this.formatter.newline() + formattedElements + this.formatter.newline() + ')');
+                    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');
@@ -2312,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');
@@ -2350,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);
             });
@@ -2373,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(', ')})`);
         }
@@ -2383,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);
@@ -2423,24 +2428,24 @@ class Deparser {
                 }
                 break;
             case 'CONSTR_CHECK':
-                if (this.formatter.isPretty() && !context.isColumnConstraint) {
-                    output.push('\n' + this.formatter.indent('CHECK'));
+                if (context.isPretty() && !context.isColumnConstraint) {
+                    output.push('\n' + context.indent('CHECK'));
                 }
                 else {
                     output.push('CHECK');
                 }
                 if (node.raw_expr) {
-                    if (this.formatter.isPretty()) {
+                    if (context.isPretty()) {
                         const checkExpr = this.visit(node.raw_expr, context);
                         if (checkExpr.includes('\n')) {
-                            output.push('(\n' + this.formatter.indent(checkExpr) + '\n)');
+                            output.push('(\n' + context.indent(checkExpr) + '\n)');
                         }
                         else {
                             output.push(`(${checkExpr})`);
                         }
                     }
                     else {
-                        output.push(this.formatter.parens(this.visit(node.raw_expr, context)));
+                        output.push(context.parens(this.visit(node.raw_expr, context)));
                     }
                 }
                 // Handle NOT VALID for check constraints
@@ -2462,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;
@@ -2520,8 +2525,8 @@ class Deparser {
                 }
                 break;
             case 'CONSTR_UNIQUE':
-                if (this.formatter.isPretty() && !context.isColumnConstraint) {
-                    output.push('\n' + this.formatter.indent('UNIQUE'));
+                if (context.isPretty() && !context.isColumnConstraint) {
+                    output.push('\n' + context.indent('UNIQUE'));
                 }
                 else {
                     output.push('UNIQUE');
@@ -2543,15 +2548,15 @@ class Deparser {
             case 'CONSTR_FOREIGN':
                 // Only add "FOREIGN KEY" for table-level constraints, not column-level constraints
                 if (!context.isColumnConstraint) {
-                    if (this.formatter.isPretty()) {
-                        output.push('\n' + this.formatter.indent('FOREIGN KEY'));
+                    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' + this.formatter.indent('REFERENCES'));
+                        output.push('\n' + context.indent('REFERENCES'));
                     }
                     else {
                         output.push('FOREIGN KEY');
@@ -2568,7 +2573,7 @@ class Deparser {
                     output.push('REFERENCES');
                 }
                 if (node.pktable) {
-                    if (this.formatter.isPretty() && !context.isColumnConstraint) {
+                    if (context.isPretty() && !context.isColumnConstraint) {
                         const lastIndex = output.length - 1;
                         if (lastIndex >= 0 && output[lastIndex].includes('REFERENCES')) {
                             output[lastIndex] += ' ' + this.RangeVar(node.pktable, context);
@@ -2585,7 +2590,7 @@ class Deparser {
                     const pkAttrs = list_utils_1.ListUtils.unwrapList(node.pk_attrs)
                         .map(attr => this.visit(attr, context))
                         .join(', ');
-                    if (this.formatter.isPretty() && !context.isColumnConstraint) {
+                    if (context.isPretty() && !context.isColumnConstraint) {
                         const lastIndex = output.length - 1;
                         if (lastIndex >= 0) {
                             output[lastIndex] += ` (${pkAttrs})`;
@@ -2608,8 +2613,8 @@ class Deparser {
                             matchClause = 'MATCH PARTIAL';
                             break;
                     }
-                    if (this.formatter.isPretty() && !context.isColumnConstraint) {
-                        output.push('\n' + this.formatter.indent(matchClause));
+                    if (context.isPretty() && !context.isColumnConstraint) {
+                        output.push('\n' + context.indent(matchClause));
                     }
                     else {
                         output.push(matchClause);
@@ -2631,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');
@@ -2655,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');
@@ -2665,8 +2670,8 @@ class Deparser {
                 }
                 // Handle NOT VALID for foreign key constraints - only for table constraints, not domain constraints
                 if (node.skip_validation && !context.isDomainConstraint) {
-                    if (this.formatter.isPretty() && !context.isColumnConstraint) {
-                        output.push('\n' + this.formatter.indent('NOT VALID'));
+                    if (context.isPretty() && !context.isColumnConstraint) {
+                        output.push('\n' + context.indent('NOT VALID'));
                     }
                     else {
                         output.push('NOT VALID');
@@ -2724,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 {
@@ -2744,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')) {
@@ -2770,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) {
@@ -2786,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;
@@ -2828,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);
             }
@@ -2848,7 +2853,7 @@ class Deparser {
         }
         return output.join(' ');
     }
-    formatWindowFrame(node) {
+    formatWindowFrame(node, context) {
         if (!node.frameOptions)
             return null;
         const frameOptions = node.frameOptions;
@@ -2857,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
@@ -2878,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) {
@@ -2889,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) {
@@ -2899,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
@@ -2918,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`);
                     }
                 }
             }
@@ -3009,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
@@ -3020,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(' ');
     }
@@ -3096,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}`;
@@ -3106,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})`;
@@ -3185,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 '';
@@ -3204,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 '';
@@ -3235,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(', ')})`);
@@ -3285,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');
@@ -3317,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));
@@ -3334,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(', ')})`;
             }
@@ -3368,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));
@@ -3516,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);
@@ -3534,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 {
@@ -3543,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 {
@@ -3562,7 +3567,7 @@ class Deparser {
             }
         }
         let result;
-        if (this.formatter.isPretty()) {
+        if (context.isPretty()) {
             result = output.join('');
         }
         else {
@@ -4165,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(', ');
@@ -4265,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})`);
         }
@@ -4311,21 +4316,19 @@ 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 commands = list_utils_1.ListUtils.unwrapList(node.cmds);
-            if (this.formatter.isPretty()) {
+            if (context.isPretty()) {
                 const commandsStr = commands
                     .map(cmd => {
                     const cmdStr = this.visit(cmd, alterContext);
                     if (cmdStr.startsWith('ADD CONSTRAINT') || cmdStr.startsWith('ADD ')) {
-                        return this.formatter.newline() + this.formatter.indent(cmdStr);
+                        return context.newline() + context.indent(cmdStr);
                     }
                     return cmdStr;
                 })
@@ -4346,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 {
@@ -4366,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);
@@ -4393,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 {
@@ -4401,7 +4404,7 @@ class Deparser {
                         }
                     }
                     else {
-                        if (context.parentNodeTypes.includes('AlterTypeStmt')) {
+                        if (context.objtype === 'OBJECT_TYPE') {
                             output.push('DROP ATTRIBUTE');
                         }
                         else {
@@ -4419,7 +4422,7 @@ class Deparser {
                     }
                     break;
                 case 'AT_AlterColumnType':
-                    if (context.parentNodeTypes.includes('AlterTypeStmt')) {
+                    if (context.objtype === 'OBJECT_TYPE') {
                         output.push('ALTER ATTRIBUTE');
                     }
                     else {
@@ -4483,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(', ');
@@ -4496,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(', ');
@@ -4591,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(', ');
@@ -4608,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(', ');
@@ -4849,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(', ');
@@ -4889,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(', ');
@@ -4993,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);
         }
@@ -5080,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(', ');
@@ -5135,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');
@@ -5168,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') &&
@@ -5184,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("'")
@@ -5244,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}'`
@@ -5253,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') {
@@ -5329,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';
@@ -5339,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';
@@ -5403,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;
@@ -5694,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(', ');
@@ -5724,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(', ');
@@ -5741,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(' ');
@@ -5755,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(' ');
@@ -5769,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(' ');
@@ -5777,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(', ');
@@ -5879,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;
@@ -5905,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;
@@ -6267,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));
             }
         }
@@ -6318,8 +6320,8 @@ class Deparser {
         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');
@@ -6328,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());
@@ -6353,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');
@@ -6362,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');
@@ -6374,18 +6376,18 @@ 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'];
@@ -6430,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(', ')})`);
         }
@@ -6613,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) {
@@ -6918,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('.');
         }
@@ -6960,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(', ')})`);
         }
@@ -6972,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(', ')})`);
         }
@@ -7004,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(')');
@@ -7022,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(')');
@@ -7043,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(', ')})`);
         }
@@ -7103,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(', ')})`);
         }
@@ -7138,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(', ')})`);
         }
@@ -7396,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');
@@ -7580,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(', ');
@@ -7888,8 +7888,8 @@ class Deparser {
         }
         if (node.action) {
             const actionStr = this.GrantStmt(node.action, context);
-            if (this.formatter.isPretty()) {
-                return output.join(' ') + this.formatter.newline() + this.formatter.indent(actionStr);
+            if (context.isPretty()) {
+                return output.join(' ') + context.newline() + context.indent(actionStr);
             }
             else {
                 output.push(actionStr);
@@ -8040,7 +8040,7 @@ class Deparser {
         if (node.trigname) {
             output.push(quote_utils_1.QuoteUtils.quote(node.trigname));
         }
-        if (this.formatter.isPretty()) {
+        if (context.isPretty()) {
             const components = [];
             const timing = [];
             if (node.timing & 2)
@@ -8066,31 +8066,31 @@ class Deparser {
             }
             if (node.events & 32)
                 events.push('TRUNCATE');
-            components.push(this.formatter.indent(timing.join(' ') + ' ' + events.join(' OR ')));
+            components.push(context.indent(timing.join(' ') + ' ' + events.join(' OR ')));
             if (node.relation) {
-                components.push(this.formatter.indent('ON ' + this.RangeVar(node.relation, context)));
+                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(this.formatter.indent('REFERENCING ' + transitionClauses));
+                components.push(context.indent('REFERENCING ' + transitionClauses));
             }
             if (node.deferrable) {
-                components.push(this.formatter.indent('DEFERRABLE'));
+                components.push(context.indent('DEFERRABLE'));
             }
             if (node.initdeferred) {
-                components.push(this.formatter.indent('INITIALLY DEFERRED'));
+                components.push(context.indent('INITIALLY DEFERRED'));
             }
             if (node.row) {
-                components.push(this.formatter.indent('FOR EACH ROW'));
+                components.push(context.indent('FOR EACH ROW'));
             }
             else {
-                components.push(this.formatter.indent('FOR EACH STATEMENT'));
+                components.push(context.indent('FOR EACH STATEMENT'));
             }
             if (node.whenClause) {
                 const whenStr = 'WHEN (' + this.visit(node.whenClause, context) + ')';
-                components.push(this.formatter.indent(whenStr));
+                components.push(context.indent(whenStr));
             }
             let executeStr = 'EXECUTE';
             if (node.funcname && node.funcname.length > 0) {
@@ -8100,7 +8100,7 @@ class Deparser {
                 executeStr += ' PROCEDURE ' + funcName;
             }
             if (node.args && node.args.length > 0) {
-                const argContext = { ...context, isStringLiteral: true };
+                const argContext = context.spawn('CreateTrigStmt', { isStringLiteral: true });
                 const args = list_utils_1.ListUtils.unwrapList(node.args)
                     .map(arg => this.visit(arg, argContext))
                     .join(', ');
@@ -8109,8 +8109,8 @@ class Deparser {
             else {
                 executeStr += '()';
             }
-            components.push(this.formatter.indent(executeStr));
-            return output.join(' ') + this.formatter.newline() + components.join(this.formatter.newline());
+            components.push(context.indent(executeStr));
+            return output.join(' ') + context.newline() + components.join(context.newline());
         }
         else {
             const timing = [];
@@ -8180,7 +8180,7 @@ class Deparser {
             }
             if (node.args && node.args.length > 0) {
                 output.push('(');
-                const argContext = { ...context, isStringLiteral: true };
+                const argContext = context.spawn('CreateTrigStmt', { isStringLiteral: true });
                 const args = list_utils_1.ListUtils.unwrapList(node.args)
                     .map(arg => this.visit(arg, argContext))
                     .join(', ');
@@ -8217,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 ');
@@ -8406,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 => {
@@ -8443,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 => {
@@ -8472,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');
@@ -8573,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');
@@ -8776,7 +8776,7 @@ class Deparser {
         }
         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(')');
@@ -8856,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);
                     });
@@ -9342,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));
             }
         }
@@ -9352,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));
             }
         }
@@ -10050,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(' '));
         }
@@ -10294,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));
         }
@@ -10324,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(', ')})`);
         }