pgsql-deparser 16.0.0 → 17.1.0

package/esm/{deparser/deparser.js → deparser.js}

@@ -1,116 +1,27 @@
-/**
- * Auto-generated file with types stripped for better tree-shaking
- * DO NOT EDIT - Generated by strip-deparser-types.ts
- */
 import { SqlFormatter } from './utils/sql-formatter';
 import { QuoteUtils } from './utils/quote-utils';
 import { ListUtils } from './utils/list-utils';
-// Type guards for better type safety
-function isParseResult(obj) {
-    // A ParseResult is an object that could have stmts (but not required)
-    // and is not already wrapped as a Node
-    // IMPORTANT: ParseResult.stmts is "repeated RawStmt" in protobuf, meaning
-    // the array contains RawStmt objects inline (not wrapped as { RawStmt: ... })
-    // Example: { version: 170004, stmts: [{ stmt: {...}, stmt_len: 32 }] }
-    return obj && typeof obj === 'object' &&
-        !Array.isArray(obj) &&
-        !('ParseResult' in obj) &&
-        !('RawStmt' in obj) &&
-        // Check if it looks like a ParseResult (has stmts or version)
-        ('stmts' in obj || 'version' in obj);
-}
-function isWrappedParseResult(obj) {
-    return obj && typeof obj === 'object' && 'ParseResult' in obj;
-}
-/**
- * Deparser - Converts PostgreSQL AST nodes back to SQL strings
- *
- * Entry Points:
- * 1. ParseResult (from libpg-query) - The complete parse result
- *    Structure: { version: number, stmts: RawStmt[] }
- *    Note: stmts is "repeated RawStmt" in protobuf, so array contains RawStmt
- *    objects inline (not wrapped as { RawStmt: ... } nodes)
- *    Example: { version: 170004, stmts: [{ stmt: {...}, stmt_len: 32 }] }
- *
- * 2. Wrapped ParseResult - When explicitly wrapped as a Node
- *    Structure: { ParseResult: { version: number, stmts: RawStmt[] } }
- *
- * 3. Wrapped RawStmt - When explicitly wrapped as a Node
- *    Structure: { RawStmt: { stmt: Node, stmt_len?: number } }
- *
- * 4. Array of Nodes - Multiple statements to deparse
- *    Can be: Node[] (e.g., SelectStmt, InsertStmt, etc.)
- *
- * 5. Single Node - Individual statement node
- *    Example: { SelectStmt: {...} }, { InsertStmt: {...} }, etc.
- *
- * The deparser automatically detects bare ParseResult objects for backward
- * compatibility and wraps them internally for consistent processing.
- */
 export class Deparser {
     formatter;
     tree;
-    options;
     constructor(tree, opts = {}) {
-        this.formatter = new SqlFormatter(opts.newline, opts.tab, opts.pretty);
-        // Set default options
-        this.options = {
-            functionDelimiter: '$$',
-            functionDelimiterFallback: '$EOFCODE$',
-            ...opts
-        };
-        // Handle different input types
-        if (isParseResult(tree)) {
-            // Duck-typed ParseResult (backward compatibility)
-            // Wrap it as a proper Node for consistent handling
-            this.tree = [{ ParseResult: tree }];
-        }
-        else if (Array.isArray(tree)) {
-            // Array of Nodes
-            this.tree = tree;
+        this.formatter = new SqlFormatter(opts.newline, opts.tab);
+        // Handle parsed query objects that contain both version and stmts
+        if (tree && typeof tree === 'object' && !Array.isArray(tree) && 'stmts' in tree) {
+            this.tree = tree.stmts;
         }
         else {
-            // Single Node (including wrapped ParseResult)
-            this.tree = [tree];
-        }
-    }
-    /**
-     * Static method to deparse PostgreSQL AST nodes to SQL
-     * @param query - Can be:
-     *   - ParseResult from libpg-query (e.g., { version: 170004, stmts: [...] })
-     *   - Wrapped ParseResult node (e.g., { ParseResult: {...} })
-     *   - Wrapped RawStmt node (e.g., { RawStmt: {...} })
-     *   - Array of Nodes
-     *   - Single Node (e.g., { SelectStmt: {...} })
-     * @param opts - Deparser options for formatting
-     * @returns The deparsed SQL string
-     */
+            this.tree = Array.isArray(tree) ? tree : [tree];
+        }
+    }
     static deparse(query, opts = {}) {
         return new Deparser(query, opts).deparseQuery();
     }
     deparseQuery() {
         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);
-            return result || '';
-        })
-            .filter(result => result !== '')
+            .map(node => this.deparse(node))
             .join(this.formatter.newline() + this.formatter.newline());
     }
-    /**
-     * Get the appropriate function delimiter based on the body content
-     * @param body The function body to check
-     * @returns The delimiter to use
-     */
-    getFunctionDelimiter(body) {
-        const delimiter = this.options.functionDelimiter || '$$';
-        if (body.includes(delimiter)) {
-            return this.options.functionDelimiterFallback || '$EOFCODE$';
-        }
-        return delimiter;
-    }
     deparse(node, context = { parentNodeTypes: [] }) {
         if (node == null) {
             return null;
@@ -128,10 +39,6 @@ export class Deparser {
     }
     visit(node, context = { parentNodeTypes: [] }) {
         const nodeType = this.getNodeType(node);
-        // Handle empty objects
-        if (!nodeType) {
-            return '';
-        }
         const nodeData = this.getNodeData(node);
         const methodName = nodeType;
         if (typeof this[methodName] === 'function') {
@@ -154,29 +61,24 @@ export class Deparser {
         }
         return node;
     }
-    ParseResult(node, context) {
-        if (!node.stmts || node.stmts.length === 0) {
-            return '';
-        }
-        // Deparse each RawStmt in the ParseResult
-        // Note: node.stmts is "repeated RawStmt" so contains RawStmt objects inline
-        // Each element has structure: { stmt: Node, stmt_len?: number, stmt_location?: number }
-        return node.stmts
-            .filter((rawStmt) => rawStmt != null)
-            .map((rawStmt) => this.RawStmt(rawStmt, context))
-            .filter((result) => result !== '')
-            .join(this.formatter.newline() + this.formatter.newline());
-    }
     RawStmt(node, context) {
-        if (!node.stmt) {
-            return '';
-        }
-        const deparsedStmt = this.deparse(node.stmt, context);
-        // Add semicolon if stmt_len is provided (indicates it had one in original)
         if (node.stmt_len) {
-            return deparsedStmt + ';';
+            return this.deparse(node.stmt, context) + ';';
+        }
+        return this.deparse(node.stmt, context);
+    }
+    stmt(node, context = { parentNodeTypes: [] }) {
+        // Handle stmt wrapper nodes that contain the actual statement
+        const keys = Object.keys(node);
+        if (keys.length === 1) {
+            const statementType = keys[0];
+            const methodName = statementType;
+            if (typeof this[methodName] === 'function') {
+                return this[methodName](node[statementType], context);
+            }
+            throw new Error(`Deparser does not handle statement type: ${statementType}`);
         }
-        return deparsedStmt;
+        return '';
     }
     SelectStmt(node, context) {
         const output = [];
@@ -185,25 +87,23 @@ export class Deparser {
         }
         if (!node.op || node.op === 'SETOP_NONE') {
             if (node.valuesLists == null) {
-                if (!this.formatter.isPretty() || !node.targetList) {
-                    output.push('SELECT');
-                }
+                output.push('SELECT');
             }
         }
         else {
             const leftStmt = this.SelectStmt(node.larg, context);
             const rightStmt = this.SelectStmt(node.rarg, context);
             // Add parentheses if the operand is a set operation OR has ORDER BY/LIMIT clauses OR has WITH clause
-            const leftNeedsParens = node.larg && (((node.larg).op && (node.larg).op !== 'SETOP_NONE') ||
-                (node.larg).sortClause ||
-                (node.larg).limitCount ||
-                (node.larg).limitOffset ||
-                (node.larg).withClause);
-            const rightNeedsParens = node.rarg && (((node.rarg).op && (node.rarg).op !== 'SETOP_NONE') ||
-                (node.rarg).sortClause ||
-                (node.rarg).limitCount ||
-                (node.rarg).limitOffset ||
-                (node.rarg).withClause);
+            const leftNeedsParens = node.larg && ((node.larg.op && node.larg.op !== 'SETOP_NONE') ||
+                node.larg.sortClause ||
+                node.larg.limitCount ||
+                node.larg.limitOffset ||
+                node.larg.withClause);
+            const rightNeedsParens = node.rarg && ((node.rarg.op && node.rarg.op !== 'SETOP_NONE') ||
+                node.rarg.sortClause ||
+                node.rarg.limitCount ||
+                node.rarg.limitOffset ||
+                node.rarg.withClause);
             if (leftNeedsParens) {
                 output.push(this.formatter.parens(leftStmt));
             }
@@ -233,82 +133,41 @@ export class Deparser {
                 output.push(rightStmt);
             }
         }
-        // Handle DISTINCT clause - in pretty mode, we'll include it in the SELECT clause
-        let distinctPart = '';
         if (node.distinctClause) {
             const distinctClause = ListUtils.unwrapList(node.distinctClause);
             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 }))
                     .join(', ');
-                distinctPart = ' DISTINCT ON ' + this.formatter.parens(clause);
+                output.push(this.formatter.parens(clause));
             }
             else {
-                distinctPart = ' DISTINCT';
-            }
-            if (!this.formatter.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 }))
-                        .join(', ');
-                    output.push(this.formatter.parens(clause));
-                }
-                else {
-                    output.push('DISTINCT');
-                }
+                output.push('DISTINCT');
             }
         }
         if (node.targetList) {
             const targetList = ListUtils.unwrapList(node.targetList);
-            if (this.formatter.isPretty()) {
-                const targetStrings = targetList
-                    .map(e => {
-                    const targetStr = this.visit(e, { ...context, select: true });
-                    if (this.containsMultilineStringLiteral(targetStr)) {
-                        return targetStr;
-                    }
-                    return this.formatter.indent(targetStr);
-                });
-                const formattedTargets = targetStrings.join(',' + this.formatter.newline());
-                output.push('SELECT' + distinctPart);
-                output.push(formattedTargets);
-            }
-            else {
-                const targets = targetList
-                    .map(e => this.visit(e, { ...context, select: true }))
-                    .join(', ');
-                output.push(targets);
-            }
+            const targets = targetList
+                .map(e => this.visit(e, { ...context, select: true }))
+                .join(', ');
+            output.push(targets);
         }
         if (node.intoClause) {
             output.push('INTO');
             output.push(this.IntoClause(node.intoClause, context));
         }
         if (node.fromClause) {
+            output.push('FROM');
             const fromList = ListUtils.unwrapList(node.fromClause);
             const fromItems = fromList
                 .map(e => this.deparse(e, { ...context, from: true }))
                 .join(', ');
-            output.push('FROM ' + fromItems.trim());
+            output.push(fromItems);
         }
         if (node.whereClause) {
-            if (this.formatter.isPretty()) {
-                output.push('WHERE');
-                const whereExpr = this.visit(node.whereClause, context);
-                const lines = whereExpr.split(this.formatter.newline());
-                const indentedLines = lines.map((line, index) => {
-                    if (index === 0) {
-                        return this.formatter.indent(line);
-                    }
-                    return line;
-                });
-                output.push(indentedLines.join(this.formatter.newline()));
-            }
-            else {
-                output.push('WHERE');
-                output.push(this.visit(node.whereClause, context));
-            }
+            output.push('WHERE');
+            output.push(this.visit(node.whereClause, context));
         }
         if (node.valuesLists) {
             output.push('VALUES');
@@ -319,43 +178,16 @@ export class Deparser {
             output.push(lists.join(', '));
         }
         if (node.groupClause) {
+            output.push('GROUP BY');
             const groupList = ListUtils.unwrapList(node.groupClause);
-            if (this.formatter.isPretty()) {
-                const groupItems = groupList
-                    .map(e => {
-                    const groupStr = this.visit(e, { ...context, group: true });
-                    if (this.containsMultilineStringLiteral(groupStr)) {
-                        return groupStr;
-                    }
-                    return this.formatter.indent(groupStr);
-                })
-                    .join(',' + this.formatter.newline());
-                output.push('GROUP BY');
-                output.push(groupItems);
-            }
-            else {
-                output.push('GROUP BY');
-                const groupItems = groupList
-                    .map(e => this.visit(e, { ...context, group: true }))
-                    .join(', ');
-                output.push(groupItems);
-            }
+            const groupItems = groupList
+                .map(e => this.visit(e, { ...context, group: true }))
+                .join(', ');
+            output.push(groupItems);
         }
         if (node.havingClause) {
-            if (this.formatter.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));
-                }
-            }
-            else {
-                output.push('HAVING');
-                output.push(this.visit(node.havingClause, context));
-            }
+            output.push('HAVING');
+            output.push(this.visit(node.havingClause, context));
         }
         if (node.windowClause) {
             output.push('WINDOW');
@@ -366,33 +198,20 @@ export class Deparser {
             output.push(windowClauses);
         }
         if (node.sortClause) {
+            output.push('ORDER BY');
             const sortList = ListUtils.unwrapList(node.sortClause);
-            if (this.formatter.isPretty()) {
-                const sortItems = sortList
-                    .map(e => {
-                    const sortStr = this.visit(e, { ...context, sort: true });
-                    if (this.containsMultilineStringLiteral(sortStr)) {
-                        return sortStr;
-                    }
-                    return this.formatter.indent(sortStr);
-                })
-                    .join(',' + this.formatter.newline());
-                output.push('ORDER BY');
-                output.push(sortItems);
-            }
-            else {
-                output.push('ORDER BY');
-                const sortItems = sortList
-                    .map(e => this.visit(e, { ...context, sort: true }))
-                    .join(', ');
-                output.push(sortItems);
-            }
+            const sortItems = sortList
+                .map(e => this.visit(e, { ...context, sort: true }))
+                .join(', ');
+            output.push(sortItems);
         }
         if (node.limitCount) {
-            output.push('LIMIT ' + this.visit(node.limitCount, context));
+            output.push('LIMIT');
+            output.push(this.visit(node.limitCount, context));
         }
         if (node.limitOffset) {
-            output.push('OFFSET ' + this.visit(node.limitOffset, context));
+            output.push('OFFSET');
+            output.push(this.visit(node.limitOffset, context));
         }
         if (node.lockingClause) {
             const lockingList = ListUtils.unwrapList(node.lockingClause);
@@ -401,10 +220,6 @@ export class Deparser {
                 .join(' ');
             output.push(lockingClauses);
         }
-        if (this.formatter.isPretty()) {
-            const filteredOutput = output.filter(item => item.trim() !== '');
-            return filteredOutput.join(this.formatter.newline());
-        }
         return output.join(' ');
     }
     A_Expr(node, context) {
@@ -469,38 +284,18 @@ export class Deparser {
                     'ALL',
                     this.formatter.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);
-                }
-                if (rexpr && this.isComplexExpression(rexpr)) {
-                    rightExpr = this.formatter.parens(rightExpr);
-                }
+            case 'AEXPR_DISTINCT':
                 return this.formatter.format([
-                    leftExpr,
+                    this.visit(lexpr, context),
                     'IS DISTINCT FROM',
-                    rightExpr
+                    this.visit(rexpr, context)
                 ]);
-            }
-            case 'AEXPR_NOT_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);
-                }
-                if (rexpr && this.isComplexExpression(rexpr)) {
-                    rightExpr = this.formatter.parens(rightExpr);
-                }
+            case 'AEXPR_NOT_DISTINCT':
                 return this.formatter.format([
-                    leftExpr,
+                    this.visit(lexpr, context),
                     'IS NOT DISTINCT FROM',
-                    rightExpr
+                    this.visit(rexpr, context)
                 ]);
-            }
             case 'AEXPR_NULLIF':
                 return this.formatter.format([
                     'NULLIF',
@@ -894,24 +689,9 @@ export class Deparser {
         if (node.recursive) {
             output.push('RECURSIVE');
         }
-        if (node.ctes && node.ctes.length > 0) {
-            const ctes = ListUtils.unwrapList(node.ctes);
-            if (this.formatter.isPretty()) {
-                const cteStrings = ctes.map((cte, index) => {
-                    const cteStr = this.visit(cte, context);
-                    const prefix = index === 0 ? this.formatter.newline() : ',' + this.formatter.newline();
-                    if (this.containsMultilineStringLiteral(cteStr)) {
-                        return prefix + cteStr;
-                    }
-                    return prefix + this.formatter.indent(cteStr);
-                });
-                output.push(cteStrings.join(''));
-            }
-            else {
-                const cteStrings = ctes.map(cte => this.visit(cte, context));
-                output.push(cteStrings.join(', '));
-            }
-        }
+        const ctes = ListUtils.unwrapList(node.ctes);
+        const cteStrs = ctes.map(cte => this.visit(cte, context));
+        output.push(cteStrs.join(', '));
         return output.join(' ');
     }
     ResTarget(node, context) {
@@ -990,28 +770,13 @@ export class Deparser {
             formatStr = '(%s)';
         }
         const boolContext = { ...context, 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 ');
-                    return formatStr.replace('%s', () => andArgs);
-                }
-                else {
-                    const andArgs = args.map(arg => this.visit(arg, boolContext)).join(' AND ');
-                    return formatStr.replace('%s', () => andArgs);
-                }
+                const andArgs = args.map(arg => this.visit(arg, boolContext)).join(' AND ');
+                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 ');
-                    return formatStr.replace('%s', () => orArgs);
-                }
-                else {
-                    const orArgs = args.map(arg => this.visit(arg, boolContext)).join(' OR ');
-                    return formatStr.replace('%s', () => orArgs);
-                }
+                const orArgs = args.map(arg => this.visit(arg, boolContext)).join(' OR ');
+                return formatStr.replace('%s', orArgs);
             case 'NOT_EXPR':
                 return `NOT (${this.visit(args[0], context)})`;
             default:
@@ -1213,13 +978,7 @@ export class Deparser {
                     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()})`;
-                    }
-                    else {
-                        result += ` OVER (${windowParts.join(' ')})`;
-                    }
+                    result += ` OVER (${windowParts.join(' ')})`;
                 }
                 else {
                     result += ` OVER ()`;
@@ -1276,23 +1035,23 @@ export class Deparser {
         else if (nodeAny.sval !== undefined) {
             if (typeof nodeAny.sval === 'object' && nodeAny.sval !== null) {
                 if (nodeAny.sval.sval !== undefined) {
-                    return QuoteUtils.formatEString(nodeAny.sval.sval);
+                    return QuoteUtils.escape(nodeAny.sval.sval);
                 }
                 else if (nodeAny.sval.String && nodeAny.sval.String.sval !== undefined) {
-                    return QuoteUtils.formatEString(nodeAny.sval.String.sval);
+                    return QuoteUtils.escape(nodeAny.sval.String.sval);
                 }
                 else if (Object.keys(nodeAny.sval).length === 0) {
                     return "''";
                 }
                 else {
-                    return QuoteUtils.formatEString(nodeAny.sval.toString());
+                    return QuoteUtils.escape(nodeAny.sval.toString());
                 }
             }
             else if (nodeAny.sval === null) {
                 return 'NULL';
             }
             else {
-                return QuoteUtils.formatEString(nodeAny.sval);
+                return QuoteUtils.escape(nodeAny.sval);
             }
         }
         else if (nodeAny.boolval !== undefined) {
@@ -1431,7 +1190,7 @@ export class Deparser {
         }
         let args = null;
         if (node.typmods) {
-            const isInterval = names.some((name) => {
+            const isInterval = names.some(name => {
                 const nameStr = typeof name === 'string' ? name : (name.String?.sval || name.String?.str);
                 return nameStr === 'interval';
             });
@@ -1600,14 +1359,7 @@ export class Deparser {
             output.push('ONLY');
         }
         let tableName = '';
-        if (node.catalogname) {
-            tableName = QuoteUtils.quote(node.catalogname);
-            if (node.schemaname) {
-                tableName += '.' + QuoteUtils.quote(node.schemaname);
-            }
-            tableName += '.' + QuoteUtils.quote(node.relname);
-        }
-        else if (node.schemaname) {
+        if (node.schemaname) {
             tableName = QuoteUtils.quote(node.schemaname) + '.' + QuoteUtils.quote(node.relname);
         }
         else {
@@ -1843,39 +1595,15 @@ export class Deparser {
             output.push(this.visit(node.arg, context));
         }
         const args = ListUtils.unwrapList(node.args);
-        if (this.formatter.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);
-                }
-                else {
-                    output.push(this.formatter.newline() + this.formatter.indent(whenClause));
-                }
-            }
-            if (node.defresult) {
-                const elseResult = this.visit(node.defresult, context);
-                if (this.containsMultilineStringLiteral(elseResult)) {
-                    output.push(this.formatter.newline() + 'ELSE ' + elseResult);
-                }
-                else {
-                    output.push(this.formatter.newline() + this.formatter.indent('ELSE ' + elseResult));
-                }
-            }
-            output.push(this.formatter.newline() + 'END');
-            return output.join(' ');
+        for (const arg of args) {
+            output.push(this.visit(arg, context));
         }
-        else {
-            for (const arg of args) {
-                output.push(this.visit(arg, context));
-            }
-            if (node.defresult) {
-                output.push('ELSE');
-                output.push(this.visit(node.defresult, context));
-            }
-            output.push('END');
-            return output.join(' ');
+        if (node.defresult) {
+            output.push('ELSE');
+            output.push(this.visit(node.defresult, context));
         }
+        output.push('END');
+        return output.join(' ');
     }
     CoalesceExpr(node, context) {
         const args = ListUtils.unwrapList(node.args);
@@ -2010,7 +1738,7 @@ export class Deparser {
     }
     String(node, context) {
         if (context.isStringLiteral || context.isEnumValue) {
-            return QuoteUtils.formatEString(node.sval || '');
+            return `'${node.sval || ''}'`;
         }
         const value = node.sval || '';
         if (context.parentNodeTypes.includes('DefElem') ||
@@ -2088,13 +1816,7 @@ export class Deparser {
             const elementStrs = elements.map(el => {
                 return this.deparse(el, context);
             });
-            if (this.formatter.isPretty()) {
-                const formattedElements = elementStrs.map(el => this.formatter.indent(el)).join(',' + this.formatter.newline());
-                output.push('(' + this.formatter.newline() + formattedElements + this.formatter.newline() + ')');
-            }
-            else {
-                output.push(this.formatter.parens(elementStrs.join(', ')));
-            }
+            output.push(this.formatter.parens(elementStrs.join(', ')));
         }
         else if (!node.partbound) {
             output.push(this.formatter.parens(''));
@@ -2333,9 +2055,6 @@ export class Deparser {
                 break;
             case 'CONSTR_UNIQUE':
                 output.push('UNIQUE');
-                if (node.nulls_not_distinct) {
-                    output.push('NULLS NOT DISTINCT');
-                }
                 if (node.keys && node.keys.length > 0) {
                     const keyList = ListUtils.unwrapList(node.keys)
                         .map(key => this.visit(key, context))
@@ -2379,52 +2098,38 @@ export class Deparser {
                     }
                 }
                 if (node.fk_upd_action && node.fk_upd_action !== 'a') {
-                    let updateClause = 'ON UPDATE ';
+                    output.push('ON UPDATE');
                     switch (node.fk_upd_action) {
                         case 'r':
-                            updateClause += 'RESTRICT';
+                            output.push('RESTRICT');
                             break;
                         case 'c':
-                            updateClause += 'CASCADE';
+                            output.push('CASCADE');
                             break;
                         case 'n':
-                            updateClause += 'SET NULL';
+                            output.push('SET NULL');
                             break;
                         case 'd':
-                            updateClause += 'SET DEFAULT';
+                            output.push('SET DEFAULT');
                             break;
                     }
-                    if (this.formatter.isPretty()) {
-                        output.push('\n' + this.formatter.indent(updateClause));
-                    }
-                    else {
-                        output.push('ON UPDATE');
-                        output.push(updateClause.replace('ON UPDATE ', ''));
-                    }
                 }
                 if (node.fk_del_action && node.fk_del_action !== 'a') {
-                    let deleteClause = 'ON DELETE ';
+                    output.push('ON DELETE');
                     switch (node.fk_del_action) {
                         case 'r':
-                            deleteClause += 'RESTRICT';
+                            output.push('RESTRICT');
                             break;
                         case 'c':
-                            deleteClause += 'CASCADE';
+                            output.push('CASCADE');
                             break;
                         case 'n':
-                            deleteClause += 'SET NULL';
+                            output.push('SET NULL');
                             break;
                         case 'd':
-                            deleteClause += 'SET DEFAULT';
+                            output.push('SET DEFAULT');
                             break;
                     }
-                    if (this.formatter.isPretty()) {
-                        output.push('\n' + this.formatter.indent(deleteClause));
-                    }
-                    else {
-                        output.push('ON DELETE');
-                        output.push(deleteClause.replace('ON DELETE ', ''));
-                    }
                 }
                 // Handle NOT VALID for foreign key constraints - only for table constraints, not domain constraints
                 if (node.skip_validation && !context.isDomainConstraint) {
@@ -2482,48 +2187,17 @@ export 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 (node.initdeferred === true) {
-                        output.push('\n' + this.formatter.indent('INITIALLY DEFERRED'));
-                    }
-                    else if (node.initdeferred === false) {
-                        output.push('\n' + this.formatter.indent('INITIALLY IMMEDIATE'));
-                    }
+                output.push('DEFERRABLE');
+                if (node.initdeferred === true) {
+                    output.push('INITIALLY DEFERRED');
                 }
-                else {
-                    output.push('DEFERRABLE');
-                    if (node.initdeferred === true) {
-                        output.push('INITIALLY DEFERRED');
-                    }
-                    else if (node.initdeferred === false) {
-                        output.push('INITIALLY IMMEDIATE');
-                    }
+                else if (node.initdeferred === false) {
+                    output.push('INITIALLY IMMEDIATE');
                 }
             }
             else if (node.deferrable === false) {
-                if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
-                    output.push('\n' + this.formatter.indent('NOT DEFERRABLE'));
-                }
-                else {
-                    output.push('NOT DEFERRABLE');
-                }
-            }
-        }
-        if (this.formatter.isPretty() && node.contype === 'CONSTR_FOREIGN') {
-            let result = '';
-            for (let i = 0; i < output.length; i++) {
-                if (output[i].startsWith('\n')) {
-                    result += output[i];
-                }
-                else {
-                    if (i > 0 && !output[i - 1].startsWith('\n')) {
-                        result += ' ';
-                    }
-                    result += output[i];
-                }
+                output.push('NOT DEFERRABLE');
             }
-            return result;
         }
         return output.join(' ');
     }
@@ -3247,9 +2921,11 @@ export class Deparser {
         }
         switch (node.jointype) {
             case 'JOIN_INNER':
+                // Handle NATURAL JOIN first - it has isNatural=true (NATURAL already added above)
                 if (node.isNatural) {
                     joinStr += 'JOIN';
                 }
+                // Handle CROSS JOIN case - when there's no quals, no usingClause, and not natural
                 else if (!node.quals && (!node.usingClause || node.usingClause.length === 0)) {
                     joinStr += 'CROSS JOIN';
                 }
@@ -3269,63 +2945,26 @@ export class Deparser {
             default:
                 joinStr += 'JOIN';
         }
+        output.push(joinStr);
         if (node.rarg) {
             let rargStr = this.visit(node.rarg, context);
             if (node.rarg && 'JoinExpr' in node.rarg && !node.rarg.JoinExpr.alias) {
                 rargStr = `(${rargStr})`;
             }
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + joinStr + ' ' + rargStr);
-            }
-            else {
-                output.push(joinStr + ' ' + rargStr);
-            }
-        }
-        else {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + joinStr);
-            }
-            else {
-                output.push(joinStr);
-            }
+            output.push(rargStr);
         }
         if (node.usingClause && node.usingClause.length > 0) {
+            output.push('USING');
             const usingList = ListUtils.unwrapList(node.usingClause);
             const columnNames = usingList.map(col => this.visit(col, context));
-            if (this.formatter.isPretty()) {
-                output.push(` USING (${columnNames.join(', ')})`);
-            }
-            else {
-                output.push(`USING (${columnNames.join(', ')})`);
-            }
+            output.push(`(${columnNames.join(', ')})`);
         }
         else if (node.quals) {
-            const qualsStr = this.visit(node.quals, context);
-            if (this.formatter.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)}`);
-                    }
-                }
-                else {
-                    output.push(` ON ${qualsStr}`);
-                }
-            }
-            else {
-                output.push(`ON ${qualsStr}`);
-            }
-        }
-        let result;
-        if (this.formatter.isPretty()) {
-            result = output.join('');
-        }
-        else {
-            result = output.join(' ');
+            output.push('ON');
+            output.push(this.visit(node.quals, context));
         }
+        let result = output.join(' ');
+        // Handle join_using_alias first (for USING clause aliases like "AS x")
         if (node.join_using_alias && node.join_using_alias.aliasname) {
             let aliasStr = node.join_using_alias.aliasname;
             if (node.join_using_alias.colnames && node.join_using_alias.colnames.length > 0) {
@@ -3335,6 +2974,7 @@ export class Deparser {
             }
             result += ` AS ${aliasStr}`;
         }
+        // Handle regular alias (for outer table aliases like "y")
         if (node.alias && node.alias.aliasname) {
             let aliasStr = node.alias.aliasname;
             if (node.alias.colnames && node.alias.colnames.length > 0) {
@@ -5146,17 +4786,17 @@ export class Deparser {
             }
             if (context.parentNodeTypes.includes('DoStmt')) {
                 if (node.defname === 'as') {
-                    const defElemContext = { ...context, parentNodeTypes: [...context.parentNodeTypes, 'DefElem'] };
-                    const argValue = node.arg ? this.visit(node.arg, defElemContext) : '';
                     if (Array.isArray(argValue)) {
                         const bodyParts = argValue;
-                        const body = bodyParts.join('');
-                        const delimiter = this.getFunctionDelimiter(body);
-                        return `${delimiter}${body}${delimiter}`;
+                        if (bodyParts.length === 1) {
+                            return `$$${bodyParts[0]}$$`;
+                        }
+                        else {
+                            return `$$${bodyParts.join('')}$$`;
+                        }
                     }
                     else {
-                        const delimiter = this.getFunctionDelimiter(argValue);
-                        return `${delimiter}${argValue}${delimiter}`;
+                        return `$$${argValue}$$`;
                     }
                 }
                 return '';
@@ -5175,14 +4815,16 @@ export class Deparser {
                         });
                         if (bodyParts.length === 1) {
                             const body = bodyParts[0];
-                            const delimiter = this.getFunctionDelimiter(body);
-                            return `AS ${delimiter}${body}${delimiter}`;
+                            // Check if body contains $$ to avoid conflicts
+                            if (body.includes('$$')) {
+                                return `AS '${body.replace(/'/g, "''")}'`;
+                            }
+                            else {
+                                return `AS $$${body}$$`;
+                            }
                         }
                         else {
-                            return `AS ${bodyParts.map((part) => {
-                                const delimiter = this.getFunctionDelimiter(part);
-                                return `${delimiter}${part}${delimiter}`;
-                            }).join(', ')}`;
+                            return `AS ${bodyParts.map((part) => `$$${part}$$`).join(', ')}`;
                         }
                     }
                     // Handle Array type (legacy support)
@@ -5190,20 +4832,27 @@ export class Deparser {
                         const bodyParts = argValue;
                         if (bodyParts.length === 1) {
                             const body = bodyParts[0];
-                            const delimiter = this.getFunctionDelimiter(body);
-                            return `AS ${delimiter}${body}${delimiter}`;
+                            // Check if body contains $$ to avoid conflicts
+                            if (body.includes('$$')) {
+                                return `AS '${body.replace(/'/g, "''")}'`;
+                            }
+                            else {
+                                return `AS $$${body}$$`;
+                            }
                         }
                         else {
-                            return `AS ${bodyParts.map(part => {
-                                const delimiter = this.getFunctionDelimiter(part);
-                                return `${delimiter}${part}${delimiter}`;
-                            }).join(', ')}`;
+                            return `AS ${bodyParts.map(part => `$$${part}$$`).join(', ')}`;
                         }
                     }
                     // Handle String type (single function body)
                     else {
-                        const delimiter = this.getFunctionDelimiter(argValue);
-                        return `AS ${delimiter}${argValue}${delimiter}`;
+                        // Check if argValue contains $$ to avoid conflicts
+                        if (argValue.includes('$$')) {
+                            return `AS '${argValue.replace(/'/g, "''")}'`;
+                        }
+                        else {
+                            return `AS $$${argValue}$$`;
+                        }
                     }
                 }
                 if (node.defname === 'language') {
@@ -5317,18 +4966,6 @@ export class Deparser {
                     : argValue;
                 return `${node.defname} = ${quotedValue}`;
             }
-            // Handle CopyStmt WITH clause options - uppercase format without quotes
-            if (context.parentNodeTypes.includes('CopyStmt')) {
-                if (node.defname === 'format' && node.arg && this.getNodeType(node.arg) === 'String') {
-                    const stringData = this.getNodeData(node.arg);
-                    return `FORMAT ${stringData.sval.toUpperCase()}`;
-                }
-                // Handle other COPY options with uppercase defname
-                if (node.arg) {
-                    return `${node.defname.toUpperCase()} ${argValue}`;
-                }
-                return node.defname.toUpperCase();
-            }
             // Handle CREATE OPERATOR and CREATE TYPE context
             if (context.parentNodeTypes.includes('DefineStmt')) {
                 const preservedName = this.preserveOperatorDefElemCase(node.defname);
@@ -6019,7 +5656,8 @@ export class Deparser {
             output.push('NULL');
         }
         else if (node.comment) {
-            output.push(QuoteUtils.formatEString(node.comment));
+            const escapedComment = node.comment.replace(/'/g, "''");
+            output.push(`'${escapedComment}'`);
         }
         return output.join(' ');
     }
@@ -6053,82 +5691,38 @@ export class Deparser {
         return output.join(' ');
     }
     CreatePolicyStmt(node, context) {
-        const output = [];
-        const initialParts = ['CREATE', 'POLICY'];
+        const output = ['CREATE', 'POLICY'];
         if (node.policy_name) {
-            initialParts.push(`"${node.policy_name}"`);
+            output.push(`"${node.policy_name}"`);
         }
-        output.push(initialParts.join(' '));
-        // Add ON clause on new line in pretty mode
+        output.push('ON');
         if (node.table) {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent(`ON ${this.RangeVar(node.table, context)}`));
-            }
-            else {
-                output.push('ON');
-                output.push(this.RangeVar(node.table, context));
-            }
+            output.push(this.RangeVar(node.table, context));
         }
         // Handle AS RESTRICTIVE/PERMISSIVE clause
         if (node.permissive === undefined) {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent('AS RESTRICTIVE'));
-            }
-            else {
-                output.push('AS', 'RESTRICTIVE');
-            }
+            output.push('AS', 'RESTRICTIVE');
         }
         else if (node.permissive === true) {
-            if (this.formatter.isPretty()) {
-                output.push(this.formatter.newline() + this.formatter.indent('AS PERMISSIVE'));
-            }
-            else {
-                output.push('AS', 'PERMISSIVE');
-            }
+            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()}`));
-            }
-            else {
-                output.push('FOR', node.cmd_name.toUpperCase());
-            }
+            output.push('FOR', node.cmd_name.toUpperCase());
         }
         if (node.roles && node.roles.length > 0) {
+            output.push('TO');
             const roles = 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(', ')}`));
-            }
-            else {
-                output.push('TO');
-                output.push(roles.join(', '));
-            }
+            output.push(roles.join(', '));
         }
         if (node.qual) {
-            if (this.formatter.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(')'));
-            }
-            else {
-                output.push('USING');
-                output.push(`(${this.visit(node.qual, context)})`);
-            }
+            output.push('USING');
+            output.push(`(${this.visit(node.qual, context)})`);
         }
         if (node.with_check) {
-            if (this.formatter.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(')'));
-            }
-            else {
-                output.push('WITH CHECK');
-                output.push(`(${this.visit(node.with_check, context)})`);
-            }
+            output.push('WITH CHECK');
+            output.push(`(${this.visit(node.with_check, context)})`);
         }
-        return this.formatter.isPretty() ? output.join('') : output.join(' ');
+        return output.join(' ');
     }
     AlterPolicyStmt(node, context) {
         const output = ['ALTER', 'POLICY'];
@@ -6368,12 +5962,12 @@ export class Deparser {
                         processedArgs.push(`LANGUAGE ${langValue}`);
                     }
                     else if (defElem.defname === 'as') {
-                        // Handle code block with configurable delimiter
+                        // Handle code block with dollar quoting
                         const argNodeType = this.getNodeType(defElem.arg);
                         if (argNodeType === 'String') {
                             const stringNode = this.getNodeData(defElem.arg);
-                            const delimiter = this.getFunctionDelimiter(stringNode.sval);
-                            processedArgs.push(`${delimiter}${stringNode.sval}${delimiter}`);
+                            const dollarTag = this.generateUniqueDollarTag(stringNode.sval);
+                            processedArgs.push(`${dollarTag}${stringNode.sval}${dollarTag}`);
                         }
                         else {
                             processedArgs.push(this.visit(defElem.arg, doContext));
@@ -6407,11 +6001,9 @@ export class Deparser {
     }
     InlineCodeBlock(node, context) {
         if (node.source_text) {
-            const delimiter = this.getFunctionDelimiter(node.source_text);
-            return `${delimiter}${node.source_text}${delimiter}`;
+            return `$$${node.source_text}$$`;
         }
-        const delimiter = this.options.functionDelimiter || '$$';
-        return `${delimiter}${delimiter}`;
+        return '$$$$';
     }
     CallContext(node, context) {
         if (node.atomic !== undefined) {
@@ -9994,8 +9586,17 @@ export class Deparser {
         }
         return output.join(' ');
     }
-    containsMultilineStringLiteral(content) {
-        const stringLiteralRegex = /'[^']*\n[^']*'/g;
-        return stringLiteralRegex.test(content);
+    version(node, context) {
+        // Handle version node - typically just return the version number
+        if (typeof node === 'number') {
+            return node.toString();
+        }
+        if (typeof node === 'string') {
+            return node;
+        }
+        if (node && typeof node === 'object' && node.version) {
+            return node.version.toString();
+        }
+        return '';
     }
 }