pgsql-deparser 18.3.7 → 18.3.8

package/deparser.js

@@ -5,6 +5,25 @@ const quotes_1 = require("@pgsql/quotes");
 const list_utils_1 = require("./utils/list-utils");
 const sql_formatter_1 = require("./utils/sql-formatter");
 const base_1 = require("./visitors/base");
+// WindowDef.frameOptions bit flags (src/include/nodes/parsenodes.h)
+const FRAMEOPTION_NONDEFAULT = 0x00001;
+const FRAMEOPTION_RANGE = 0x00002;
+const FRAMEOPTION_ROWS = 0x00004;
+const FRAMEOPTION_GROUPS = 0x00008;
+const FRAMEOPTION_BETWEEN = 0x00010;
+const FRAMEOPTION_START_UNBOUNDED_PRECEDING = 0x00020;
+const FRAMEOPTION_END_UNBOUNDED_PRECEDING = 0x00040;
+const FRAMEOPTION_START_UNBOUNDED_FOLLOWING = 0x00080;
+const FRAMEOPTION_END_UNBOUNDED_FOLLOWING = 0x00100;
+const FRAMEOPTION_START_CURRENT_ROW = 0x00200;
+const FRAMEOPTION_END_CURRENT_ROW = 0x00400;
+const FRAMEOPTION_START_OFFSET_PRECEDING = 0x00800;
+const FRAMEOPTION_END_OFFSET_PRECEDING = 0x01000;
+const FRAMEOPTION_START_OFFSET_FOLLOWING = 0x02000;
+const FRAMEOPTION_END_OFFSET_FOLLOWING = 0x04000;
+const FRAMEOPTION_EXCLUDE_CURRENT_ROW = 0x08000;
+const FRAMEOPTION_EXCLUDE_GROUP = 0x10000;
+const FRAMEOPTION_EXCLUDE_TIES = 0x20000;
 /**
  * List of real PostgreSQL built-in types as they appear in pg_catalog.pg_type.typname.
  * These are stored in lowercase in PostgreSQL system catalogs.
@@ -984,6 +1003,12 @@ class Deparser {
                 output.push(context.parens(columnNames.join(', ')));
             }
         }
+        if (node.override === 'OVERRIDING_USER_VALUE') {
+            output.push('OVERRIDING USER VALUE');
+        }
+        else if (node.override === 'OVERRIDING_SYSTEM_VALUE') {
+            output.push('OVERRIDING SYSTEM VALUE');
+        }
         if (node.selectStmt) {
             output.push(this.visit(node.selectStmt, context));
         }
@@ -1060,38 +1085,8 @@ class Deparser {
             output.push(this.RangeVar(node.relation, context));
         }
         output.push('SET');
-        const targetList = list_utils_1.ListUtils.unwrapList(node.targetList);
-        if (targetList && targetList.length) {
-            const firstTarget = targetList[0];
-            const processedTargets = new Set();
-            const assignmentParts = [];
-            for (let i = 0; i < targetList.length; i++) {
-                if (processedTargets.has(i))
-                    continue;
-                const target = targetList[i];
-                const multiAssignRef = target.ResTarget?.val?.MultiAssignRef;
-                if (multiAssignRef) {
-                    const relatedTargets = [];
-                    for (let j = i; j < targetList.length; j++) {
-                        const otherTarget = targetList[j];
-                        const otherMultiAssignRef = otherTarget.ResTarget?.val?.MultiAssignRef;
-                        if (otherMultiAssignRef &&
-                            JSON.stringify(otherMultiAssignRef.source) === JSON.stringify(multiAssignRef.source)) {
-                            relatedTargets.push(otherTarget);
-                            processedTargets.add(j);
-                        }
-                    }
-                    const names = relatedTargets.map(t => t.ResTarget.name);
-                    const multiAssignment = `${context.parens(names.join(', '))} = ${this.visit(multiAssignRef.source, context)}`;
-                    assignmentParts.push(multiAssignment);
-                }
-                else {
-                    // Handle regular single-column assignment
-                    assignmentParts.push(this.visit(target, context.spawn('UpdateStmt', { update: true })));
-                    processedTargets.add(i);
-                }
-            }
-            output.push(assignmentParts.join(','));
+        if (node.targetList && node.targetList.length > 0) {
+            output.push(this.formatUpdateAssignments(node.targetList, context));
         }
         if (node.fromClause) {
             output.push('FROM');
@@ -1108,6 +1103,36 @@ class Deparser {
         }
         return output.join(' ');
     }
+    formatUpdateAssignments(targets, context) {
+        const targetList = list_utils_1.ListUtils.unwrapList(targets);
+        const processedTargets = new Set();
+        const assignmentParts = [];
+        for (let i = 0; i < targetList.length; i++) {
+            if (processedTargets.has(i))
+                continue;
+            const target = targetList[i];
+            const multiAssignRef = target.ResTarget?.val?.MultiAssignRef;
+            if (multiAssignRef) {
+                const relatedTargets = [];
+                for (let j = i; j < targetList.length; j++) {
+                    const otherTarget = targetList[j];
+                    const otherMultiAssignRef = otherTarget.ResTarget?.val?.MultiAssignRef;
+                    if (otherMultiAssignRef &&
+                        JSON.stringify(otherMultiAssignRef.source) === JSON.stringify(multiAssignRef.source)) {
+                        relatedTargets.push(otherTarget);
+                        processedTargets.add(j);
+                    }
+                }
+                const names = relatedTargets.map(t => quotes_1.QuoteUtils.quoteIdentifier(t.ResTarget.name));
+                assignmentParts.push(`${context.parens(names.join(', '))} = ${this.visit(multiAssignRef.source, context)}`);
+            }
+            else {
+                assignmentParts.push(this.visit(target, context.spawn('UpdateStmt', { update: true })));
+                processedTargets.add(i);
+            }
+        }
+        return assignmentParts.join(', ');
+    }
     DeleteStmt(node, context) {
         try {
             const output = [];
@@ -1520,43 +1545,41 @@ class Deparser {
             result += ` FILTER (WHERE ${this.visit(node.agg_filter, context)})`;
         }
         if (node.over) {
-            // Handle named window references first
-            if (node.over.name) {
-                result += ` OVER ${node.over.name}`;
-            }
-            else {
-                const windowParts = [];
-                if (node.over.partitionClause) {
-                    const partitions = list_utils_1.ListUtils.unwrapList(node.over.partitionClause);
-                    const partitionStrs = partitions.map(p => this.visit(p, context));
-                    windowParts.push(`PARTITION BY ${partitionStrs.join(', ')}`);
-                }
-                if (node.over.orderClause) {
-                    const orders = list_utils_1.ListUtils.unwrapList(node.over.orderClause);
-                    const orderStrs = orders.map(o => this.visit(o, context));
-                    windowParts.push(`ORDER BY ${orderStrs.join(', ')}`);
-                }
-                // Handle window frame specifications using the dedicated formatWindowFrame method
-                const frameClause = this.formatWindowFrame(node.over, context.spawn('FuncCall'));
-                if (frameClause) {
-                    windowParts.push(frameClause);
-                }
-                if (windowParts.length > 0) {
-                    if (context.isPretty() && windowParts.length > 1) {
-                        const formattedParts = windowParts.map(part => context.indent(part));
-                        result += ` OVER (${context.newline()}${formattedParts.join(context.newline())}${context.newline()})`;
-                    }
-                    else {
-                        result += ` OVER (${windowParts.join(' ')})`;
-                    }
-                }
-                else {
-                    result += ` OVER ()`;
-                }
-            }
+            result += this.formatOverClause(node.over, context);
         }
         return result;
     }
+    formatOverClause(over, context) {
+        if (over.name) {
+            return ` OVER ${over.name}`;
+        }
+        const windowParts = [];
+        if (over.refname) {
+            windowParts.push(over.refname);
+        }
+        if (over.partitionClause) {
+            const partitions = list_utils_1.ListUtils.unwrapList(over.partitionClause);
+            const partitionStrs = partitions.map(p => this.visit(p, context));
+            windowParts.push(`PARTITION BY ${partitionStrs.join(', ')}`);
+        }
+        if (over.orderClause) {
+            const orders = list_utils_1.ListUtils.unwrapList(over.orderClause);
+            const orderStrs = orders.map(o => this.visit(o, context));
+            windowParts.push(`ORDER BY ${orderStrs.join(', ')}`);
+        }
+        const frameClause = this.formatWindowFrame(over, context.spawn('FuncCall'));
+        if (frameClause) {
+            windowParts.push(frameClause);
+        }
+        if (windowParts.length === 0) {
+            return ' OVER ()';
+        }
+        if (context.isPretty() && windowParts.length > 1) {
+            const formattedParts = windowParts.map(part => context.indent(part));
+            return ` OVER (${context.newline()}${formattedParts.join(context.newline())}${context.newline()})`;
+        }
+        return ` OVER (${windowParts.join(' ')})`;
+    }
     FuncExpr(node, context) {
         const funcName = `func_${node.funcid}`;
         const args = node.args ? list_utils_1.ListUtils.unwrapList(node.args).map(arg => this.visit(arg, context)).join(', ') : '';
@@ -2419,7 +2442,7 @@ class Deparser {
                 output.push(context.parens(elementStrs.join(', ')));
             }
         }
-        else if (node.tableElts) {
+        else if (node.tableElts && !node.partbound) {
             const elements = list_utils_1.ListUtils.unwrapList(node.tableElts);
             const elementStrs = elements.map(el => {
                 return this.deparse(el, context.spawn('CreateStmt'));
@@ -2447,7 +2470,16 @@ class Deparser {
             const inherits = list_utils_1.ListUtils.unwrapList(node.inhRelations);
             const inheritStrs = inherits.map(rel => this.visit(rel, context));
             output.push(inheritStrs[0]);
-            if (node.partbound.strategy === 'l' && node.partbound.listdatums) {
+            if (node.tableElts) {
+                const elementStrs = list_utils_1.ListUtils.unwrapList(node.tableElts).map(el => {
+                    return this.deparse(el, context.spawn('CreateStmt'));
+                });
+                output.push(context.parens(elementStrs.join(', ')));
+            }
+            if (node.partbound.is_default) {
+                output.push('DEFAULT');
+            }
+            else if (node.partbound.strategy === 'l' && node.partbound.listdatums) {
                 output.push('FOR VALUES IN');
                 const listValues = list_utils_1.ListUtils.unwrapList(node.partbound.listdatums)
                     .map(datum => this.visit(datum, context))
@@ -2470,13 +2502,9 @@ class Deparser {
                     output.push(`(${upperValues})`);
                 }
             }
-            else if (node.partbound.strategy === 'h' && node.partbound.modulus !== undefined) {
+            else if (node.partbound.strategy === 'h') {
                 output.push('FOR VALUES WITH');
-                const remainder = node.partbound.remainder !== undefined ? node.partbound.remainder : 0;
-                output.push(`(MODULUS ${node.partbound.modulus}, REMAINDER ${remainder})`);
-            }
-            else if (node.partbound.is_default) {
-                output.push('DEFAULT');
+                output.push(`(MODULUS ${node.partbound.modulus ?? 0}, REMAINDER ${node.partbound.remainder ?? 0})`);
             }
         }
         else if (node.inhRelations) {
@@ -2542,6 +2570,12 @@ class Deparser {
         if (node.typeName) {
             output.push(this.TypeName(node.typeName, context));
         }
+        if (node.storage_name) {
+            output.push('STORAGE', node.storage_name.toUpperCase());
+        }
+        if (node.compression) {
+            output.push('COMPRESSION', quotes_1.QuoteUtils.quoteIdentifier(node.compression));
+        }
         if (node.fdwoptions && node.fdwoptions.length > 0) {
             output.push('OPTIONS');
             const columnContext = context.spawn('ColumnDef');
@@ -2602,7 +2636,8 @@ class Deparser {
             case 'CONSTR_DEFAULT':
                 output.push('DEFAULT');
                 if (node.raw_expr) {
-                    output.push(this.visit(node.raw_expr, context));
+                    const defaultExpr = this.visit(node.raw_expr, context);
+                    output.push(this.needsBExprParens(node.raw_expr) ? `(${defaultExpr})` : defaultExpr);
                 }
                 break;
             case 'CONSTR_CHECK':
@@ -2966,7 +3001,7 @@ class Deparser {
                 break;
         }
         // Handle deferrable constraints for all constraint types that support it
-        if (node.contype === 'CONSTR_PRIMARY' || node.contype === 'CONSTR_UNIQUE' || node.contype === 'CONSTR_FOREIGN') {
+        if (node.contype === 'CONSTR_PRIMARY' || node.contype === 'CONSTR_UNIQUE' || node.contype === 'CONSTR_FOREIGN' || node.contype === 'CONSTR_EXCLUSION') {
             if (node.deferrable) {
                 if (context.isPretty() && node.contype === 'CONSTR_FOREIGN') {
                     output.push('\n' + context.indent('DEFERRABLE'));
@@ -2995,6 +3030,9 @@ class Deparser {
                     output.push('NOT DEFERRABLE');
                 }
             }
+            else if (node.initdeferred) {
+                output.push('INITIALLY DEFERRED');
+            }
         }
         if (context.isPretty() && node.contype === 'CONSTR_FOREIGN') {
             let result = '';
@@ -3060,6 +3098,9 @@ class Deparser {
             output.push(node.name);
         }
         const windowParts = [];
+        if (node.refname) {
+            windowParts.push(node.refname);
+        }
         if (node.partitionClause) {
             const partitions = list_utils_1.ListUtils.unwrapList(node.partitionClause);
             const partitionStrs = partitions.map(p => this.visit(p, context));
@@ -3070,12 +3111,9 @@ class Deparser {
             const orderStrs = orders.map(o => this.visit(o, context));
             windowParts.push(`ORDER BY ${orderStrs.join(', ')}`);
         }
-        // Only add frame clause if frameOptions indicates non-default framing
-        if (node.frameOptions && node.frameOptions !== 1058) {
-            const frameClause = this.formatWindowFrame(node, context.spawn('WindowDef'));
-            if (frameClause) {
-                windowParts.push(frameClause);
-            }
+        const frameClause = this.formatWindowFrame(node, context.spawn('WindowDef'));
+        if (frameClause) {
+            windowParts.push(frameClause);
         }
         if (windowParts.length > 0) {
             if (node.name) {
@@ -3092,114 +3130,96 @@ class Deparser {
         }
         return output.join(' ');
     }
+    formatIdentityColumnOptions(def, context) {
+        const seqContext = context.spawn('AlterSeqStmt');
+        return list_utils_1.ListUtils.unwrapList(def).map(item => {
+            const el = item.DefElem;
+            if (!el)
+                return this.visit(item, context);
+            if (el.defname === 'generated') {
+                const ival = el.arg?.Integer?.ival ?? 0;
+                return ival === 97 ? 'SET GENERATED ALWAYS' : 'SET GENERATED BY DEFAULT';
+            }
+            if (el.defname === 'restart') {
+                return el.arg ? `RESTART WITH ${this.visit(el.arg, context)}` : 'RESTART';
+            }
+            return `SET ${this.visit(item, seqContext)}`;
+        }).join(' ');
+    }
+    // b_expr (used by DEFAULT) excludes IN/LIKE/BETWEEN and boolean operators.
+    needsBExprParens(node) {
+        const nodeType = this.getNodeType(node);
+        if (nodeType === 'BoolExpr')
+            return true;
+        if (nodeType === 'A_Expr') {
+            const kind = this.getNodeData(node).kind;
+            return kind !== 'AEXPR_OP' && kind !== 'AEXPR_DISTINCT' && kind !== 'AEXPR_NOT_DISTINCT';
+        }
+        return false;
+    }
     formatWindowFrame(node, context) {
-        if (!node.frameOptions)
+        if (!node.frameOptions || !(node.frameOptions & FRAMEOPTION_NONDEFAULT))
             return null;
         const frameOptions = node.frameOptions;
-        const EXCLUDE_MASK = 0x8000 | 0x10000 | 0x20000;
-        const baseFrameOptions = frameOptions & ~EXCLUDE_MASK;
         const frameParts = [];
-        if (frameOptions & 0x01) { // FRAMEOPTION_NONDEFAULT
-            if (frameOptions & 0x02) { // FRAMEOPTION_RANGE
-                frameParts.push('RANGE');
-            }
-            else if (frameOptions & 0x04) { // FRAMEOPTION_ROWS
-                frameParts.push('ROWS');
-            }
-            else if (frameOptions & 0x08) { // FRAMEOPTION_GROUPS
-                frameParts.push('GROUPS');
-            }
+        if (frameOptions & FRAMEOPTION_RANGE) {
+            frameParts.push('RANGE');
+        }
+        else if (frameOptions & FRAMEOPTION_ROWS) {
+            frameParts.push('ROWS');
+        }
+        else if (frameOptions & FRAMEOPTION_GROUPS) {
+            frameParts.push('GROUPS');
         }
         if (frameParts.length === 0)
             return null;
-        const boundsParts = [];
-        // Handle specific frameOptions values that have known mappings
-        if (baseFrameOptions === 789) {
-            boundsParts.push('CURRENT ROW');
-            boundsParts.push('AND UNBOUNDED FOLLOWING');
+        let start = null;
+        if (frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
+            start = 'UNBOUNDED PRECEDING';
         }
-        else if (baseFrameOptions === 1077) {
-            boundsParts.push('UNBOUNDED PRECEDING');
-            boundsParts.push('AND CURRENT ROW');
+        else if (frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING) {
+            start = 'UNBOUNDED FOLLOWING';
         }
-        else if (baseFrameOptions === 18453) {
-            if (node.startOffset && node.endOffset) {
-                boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
-                boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-            }
+        else if (frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
+            start = 'CURRENT ROW';
         }
-        else if (baseFrameOptions === 1557) {
-            boundsParts.push('CURRENT ROW');
-            boundsParts.push('AND CURRENT ROW');
+        else if (frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING && node.startOffset) {
+            start = `${this.visit(node.startOffset, context)} PRECEDING`;
         }
-        else if (baseFrameOptions === 16917) {
-            boundsParts.push('CURRENT ROW');
-            if (node.endOffset) {
-                boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-            }
+        else if (frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING && node.startOffset) {
+            start = `${this.visit(node.startOffset, context)} FOLLOWING`;
         }
-        else if (baseFrameOptions === 1058) {
-            return null;
+        let end = null;
+        if (frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) {
+            end = 'UNBOUNDED PRECEDING';
         }
-        else {
-            // Handle start bound - prioritize explicit offset values over bit flags
-            if (node.startOffset) {
-                if (frameOptions & 0x400) { // FRAMEOPTION_START_VALUE_PRECEDING
-                    boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
-                }
-                else if (frameOptions & 0x800) { // FRAMEOPTION_START_VALUE_FOLLOWING
-                    boundsParts.push(`${this.visit(node.startOffset, context)} FOLLOWING`);
-                }
-                else {
-                    boundsParts.push(`${this.visit(node.startOffset, context)} PRECEDING`);
-                }
-            }
-            else if (frameOptions & 0x10) { // FRAMEOPTION_START_UNBOUNDED_PRECEDING
-                boundsParts.push('UNBOUNDED PRECEDING');
-            }
-            else if (frameOptions & 0x20) { // FRAMEOPTION_START_CURRENT_ROW
-                boundsParts.push('CURRENT ROW');
-            }
-            // Handle end bound - prioritize explicit offset values over bit flags
-            if (node.endOffset) {
-                if (boundsParts.length > 0) {
-                    if (frameOptions & 0x1000) { // FRAMEOPTION_END_VALUE_PRECEDING
-                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} PRECEDING`);
-                    }
-                    else if (frameOptions & 0x2000) { // FRAMEOPTION_END_VALUE_FOLLOWING
-                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-                    }
-                    else {
-                        boundsParts.push(`AND ${this.visit(node.endOffset, context)} FOLLOWING`);
-                    }
-                }
-            }
-            else if (frameOptions & 0x80) { // FRAMEOPTION_END_UNBOUNDED_FOLLOWING
-                if (boundsParts.length > 0) {
-                    boundsParts.push('AND UNBOUNDED FOLLOWING');
-                }
-            }
-            else if (frameOptions & 0x100) { // FRAMEOPTION_END_CURRENT_ROW
-                if (boundsParts.length > 0) {
-                    boundsParts.push('AND CURRENT ROW');
-                }
+        else if (frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
+            end = 'UNBOUNDED FOLLOWING';
+        }
+        else if (frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
+            end = 'CURRENT ROW';
+        }
+        else if (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING && node.endOffset) {
+            end = `${this.visit(node.endOffset, context)} PRECEDING`;
+        }
+        else if (frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING && node.endOffset) {
+            end = `${this.visit(node.endOffset, context)} FOLLOWING`;
+        }
+        if (start) {
+            if (frameOptions & FRAMEOPTION_BETWEEN) {
+                frameParts.push(`BETWEEN ${start} AND ${end ?? 'CURRENT ROW'}`);
             }
-            else if (boundsParts.length > 0) {
-                boundsParts.push('AND CURRENT ROW');
+            else {
+                frameParts.push(start);
             }
         }
-        if (boundsParts.length > 0) {
-            frameParts.push('BETWEEN');
-            frameParts.push(boundsParts.join(' '));
-        }
-        // EXCLUDE clause
-        if (frameOptions & 0x8000) { // FRAMEOPTION_EXCLUDE_CURRENT_ROW
+        if (frameOptions & FRAMEOPTION_EXCLUDE_CURRENT_ROW) {
             frameParts.push('EXCLUDE CURRENT ROW');
         }
-        else if (frameOptions & 0x10000) { // FRAMEOPTION_EXCLUDE_GROUP
+        else if (frameOptions & FRAMEOPTION_EXCLUDE_GROUP) {
             frameParts.push('EXCLUDE GROUP');
         }
-        else if (frameOptions & 0x20000) { // FRAMEOPTION_EXCLUDE_TIES
+        else if (frameOptions & FRAMEOPTION_EXCLUDE_TIES) {
             frameParts.push('EXCLUDE TIES');
         }
         return frameParts.join(' ');
@@ -3278,8 +3298,35 @@ class Deparser {
         if (node.ctequery) {
             output.push(context.parens(this.visit(node.ctequery, context)));
         }
+        if (node.search_clause) {
+            const sc = node.search_clause;
+            const cols = list_utils_1.ListUtils.unwrapList(sc.search_col_list).map(c => this.visit(c, context));
+            output.push('SEARCH', sc.search_breadth_first ? 'BREADTH' : 'DEPTH', 'FIRST BY');
+            output.push(cols.join(', '));
+            output.push('SET', quotes_1.QuoteUtils.quoteIdentifier(sc.search_seq_column));
+        }
+        if (node.cycle_clause) {
+            const cc = node.cycle_clause;
+            const cols = list_utils_1.ListUtils.unwrapList(cc.cycle_col_list).map(c => this.visit(c, context));
+            output.push('CYCLE', cols.join(', '));
+            output.push('SET', quotes_1.QuoteUtils.quoteIdentifier(cc.cycle_mark_column));
+            if (cc.cycle_mark_value && cc.cycle_mark_default) {
+                output.push('TO', this.formatAexprConst(cc.cycle_mark_value, context));
+                output.push('DEFAULT', this.formatAexprConst(cc.cycle_mark_default, context));
+            }
+            output.push('USING', quotes_1.QuoteUtils.quoteIdentifier(cc.cycle_path_column));
+        }
         return output.join(' ');
     }
+    // Renders a constant in the restricted AexprConst grammar (e.g. `point '(1,1)'`
+    // rather than `CAST('(1,1)' AS point)`).
+    formatAexprConst(node, context) {
+        const cast = node.TypeCast;
+        if (cast?.arg?.A_Const?.sval && cast.typeName) {
+            return `${this.TypeName(cast.typeName, context)} ${this.visit(cast.arg, context)}`;
+        }
+        return this.visit(node, context);
+    }
     ParamRef(node, context) {
         return `$${node.number}`;
     }
@@ -3669,9 +3716,9 @@ class Deparser {
                     output.push(`(${upperValues})`);
                 }
             }
-            else if (node.bound.strategy === 'h' && node.bound.modulus !== undefined) {
+            else if (node.bound.strategy === 'h') {
                 output.push('FOR VALUES WITH');
-                output.push(`(MODULUS ${node.bound.modulus}, REMAINDER ${node.bound.remainder ?? 0})`);
+                output.push(`(MODULUS ${node.bound.modulus ?? 0}, REMAINDER ${node.bound.remainder ?? 0})`);
             }
             else if (node.bound.is_default) {
                 output.push('DEFAULT');
@@ -4524,10 +4571,10 @@ class Deparser {
             output.push('PROGRAM');
         }
         if (node.filename) {
-            output.push(`'${node.filename}'`);
+            output.push(quotes_1.QuoteUtils.escape(node.filename));
         }
         else {
-            output.push('STDIN');
+            output.push(node.is_from ? 'STDIN' : 'STDOUT');
         }
         if (node.options && node.options.length > 0) {
             output.push('WITH');
@@ -4759,6 +4806,9 @@ class Deparser {
                         const nodeData = this.getNodeData(node.def);
                         if (nodeData && nodeData.typeName) {
                             output.push(this.TypeName(nodeData.typeName, context));
+                            if (nodeData.collClause) {
+                                output.push(this.CollateClause(nodeData.collClause, context));
+                            }
                             // Handle USING clause (stored in raw_default for ALTER COLUMN TYPE)
                             if (nodeData.raw_default) {
                                 output.push('USING');
@@ -5239,9 +5289,8 @@ class Deparser {
                     if (node.name) {
                         output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
-                    output.push('SET');
                     if (node.def) {
-                        output.push(this.visit(node.def, context));
+                        output.push(this.formatIdentityColumnOptions(node.def, context));
                     }
                     break;
                 case 'AT_DropIdentity':
@@ -5250,11 +5299,8 @@ class Deparser {
                         output.push(quotes_1.QuoteUtils.quoteIdentifier(node.name));
                     }
                     output.push('DROP IDENTITY');
-                    if (node.behavior === 'DROP_CASCADE') {
-                        output.push('CASCADE');
-                    }
-                    else if (node.behavior === 'DROP_RESTRICT') {
-                        output.push('RESTRICT');
+                    if (node.missing_ok) {
+                        output.push('IF EXISTS');
                     }
                     break;
                 case 'AT_ReAddStatistics':
@@ -5690,6 +5736,9 @@ class Deparser {
                     if (node.arg && this.getNodeType(node.arg) === 'List') {
                         const listData = this.getNodeData(node.arg);
                         const listItems = list_utils_1.ListUtils.unwrapList(listData.items);
+                        if (listItems.length === 1 && listItems[0].String?.sval === 'none') {
+                            return 'OWNED BY NONE';
+                        }
                         const parts = listItems.map(item => {
                             const itemData = this.getNodeData(item);
                             if (this.getNodeType(item) === 'String') {
@@ -5867,12 +5916,15 @@ class Deparser {
             }
             // Handle CreateStmt table options - no quotes, compact formatting
             if (context.parentNodeTypes.includes('CreateStmt')) {
+                const relOptName = node.defnamespace
+                    ? `${quotes_1.QuoteUtils.quoteIdentifier(node.defnamespace)}.${quotes_1.QuoteUtils.quoteIdentifier(node.defname)}`
+                    : quotes_1.QuoteUtils.quoteIdentifier(node.defname);
                 // For numeric values, use the raw value without quotes
                 if (node.arg && this.getNodeType(node.arg) === 'Integer') {
                     const integerData = this.getNodeData(node.arg);
-                    return `${node.defname}=${integerData.ival}`;
+                    return `${relOptName}=${integerData.ival}`;
                 }
-                return `${node.defname}=${argValue}`;
+                return `${relOptName}=${argValue}`;
             }
             // Handle CreateEventTrigStmt WHEN clause - use IN syntax for List arguments
             if (context.parentNodeTypes.includes('CreateEventTrigStmt')) {
@@ -5911,15 +5963,27 @@ class Deparser {
             }
             // Handle CopyStmt WITH clause options - uppercase format without quotes
             if (context.parentNodeTypes.includes('CopyStmt')) {
-                if (node.defname === 'format' && node.arg && this.getNodeType(node.arg) === 'String') {
-                    const stringData = this.getNodeData(node.arg);
-                    return `FORMAT ${stringData.sval.toUpperCase()}`;
+                const optName = node.defname.toUpperCase();
+                if (!node.arg) {
+                    return optName;
+                }
+                const copyArgType = this.getNodeType(node.arg);
+                if (copyArgType === 'Boolean' && this.getNodeData(node.arg).boolval !== false) {
+                    return optName;
+                }
+                if (copyArgType === 'List') {
+                    const items = list_utils_1.ListUtils.unwrapList(this.getNodeData(node.arg).items)
+                        .map(item => this.visit(item, context));
+                    return `${optName} (${items.join(', ')})`;
                 }
-                // Handle other COPY options with uppercase defname
-                if (node.arg) {
-                    return `${node.defname.toUpperCase()} ${argValue}`;
+                if (copyArgType === 'String') {
+                    const sval = this.getNodeData(node.arg).sval;
+                    if (node.defname === 'format') {
+                        return `${optName} ${sval}`;
+                    }
+                    return `${optName} ${quotes_1.QuoteUtils.escape(sval)}`;
                 }
-                return node.defname.toUpperCase();
+                return `${optName} ${argValue}`;
             }
             // Handle CREATE OPERATOR and CREATE TYPE context
             if (context.parentNodeTypes.includes('DefineStmt')) {
@@ -6000,6 +6064,10 @@ class Deparser {
                     return `${node.defname} = ${argValue}`;
                 }
             }
+            const argType = this.getNodeType(node.arg);
+            if (argType === 'TypeName' || argType === 'Integer' || argType === 'Float' || argType === 'Boolean') {
+                return `${node.defname} = ${argValue}`;
+            }
             const quotedValue = typeof argValue === 'string'
                 ? quotes_1.QuoteUtils.escape(argValue)
                 : argValue;
@@ -6433,6 +6501,9 @@ class Deparser {
                 case 'OBJECT_TABCONSTRAINT':
                     output.push('CONSTRAINT');
                     break;
+                case 'OBJECT_DOMCONSTRAINT':
+                    output.push('CONSTRAINT');
+                    break;
                 case 'OBJECT_TRIGGER':
                     output.push('TRIGGER');
                     break;
@@ -6509,6 +6580,15 @@ class Deparser {
                             output.push(objectParts.join('.'));
                         }
                     }
+                    else if (node.objtype === 'OBJECT_DOMCONSTRAINT') {
+                        if (objectParts.length === 2) {
+                            const [domain, constraint] = objectParts;
+                            output.push(constraint, 'ON DOMAIN', domain);
+                        }
+                        else {
+                            output.push(objectParts.join('.'));
+                        }
+                    }
                     else if (node.objtype === 'OBJECT_TRIGGER') {
                         if (objectParts.length === 2) {
                             const [table, trigger] = objectParts;
@@ -6840,7 +6920,7 @@ class Deparser {
             output.push(quotes_1.QuoteUtils.quoteIdentifier(node.pubname));
         }
         if (node.pubobjects && node.pubobjects.length > 0) {
-            output.push('FOR', 'TABLE');
+            output.push('FOR');
             const tables = list_utils_1.ListUtils.unwrapList(node.pubobjects).map(table => this.visit(table, context));
             output.push(tables.join(', '));
         }
@@ -6880,8 +6960,9 @@ class Deparser {
         if (node.pubname) {
             output.push(quotes_1.QuoteUtils.quoteIdentifier(node.pubname));
         }
-        if (node.action) {
-            switch (node.action) {
+        const hasObjects = node.pubobjects && node.pubobjects.length > 0;
+        if (hasObjects) {
+            switch (node.action || 'AP_AddObjects') {
                 case 'AP_AddObjects':
                     output.push('ADD');
                     break;
@@ -6894,17 +6975,11 @@ class Deparser {
                 default:
                     throw new Error(`Unsupported AlterPublicationStmt action: ${node.action}`);
             }
-        }
-        if (node.for_all_tables) {
-            output.push('FOR ALL TABLES');
-        }
-        else if (node.pubobjects && node.pubobjects.length > 0) {
-            output.push('FOR TABLE');
             const objects = list_utils_1.ListUtils.unwrapList(node.pubobjects).map(obj => this.visit(obj, context));
             output.push(objects.join(', '));
         }
-        if (node.options && node.options.length > 0) {
-            output.push('WITH');
+        else if (node.options && node.options.length > 0) {
+            output.push('SET');
             const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, context));
             output.push(`(${options.join(', ')})`);
         }
@@ -6915,42 +6990,67 @@ class Deparser {
         if (node.subname) {
             output.push(quotes_1.QuoteUtils.quoteIdentifier(node.subname));
         }
-        if (node.kind) {
-            switch (node.kind) {
+        const options = node.options && node.options.length > 0
+            ? `(${list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, context)).join(', ')})`
+            : null;
+        const publications = node.publication && node.publication.length > 0
+            ? list_utils_1.ListUtils.unwrapList(node.publication).map(pub => this.visit(pub, context)).join(', ')
+            : null;
+        {
+            switch (node.kind || 'ALTER_SUBSCRIPTION_OPTIONS') {
                 case 'ALTER_SUBSCRIPTION_OPTIONS':
                     output.push('SET');
+                    if (options)
+                        output.push(options);
                     break;
                 case 'ALTER_SUBSCRIPTION_CONNECTION':
                     output.push('CONNECTION');
                     if (node.conninfo) {
-                        output.push(`'${node.conninfo}'`);
+                        output.push(quotes_1.QuoteUtils.escape(node.conninfo));
                     }
                     break;
                 case 'ALTER_SUBSCRIPTION_SET_PUBLICATION':
                     output.push('SET PUBLICATION');
-                    if (node.publication && node.publication.length > 0) {
-                        const publications = list_utils_1.ListUtils.unwrapList(node.publication).map(pub => this.visit(pub, context));
-                        output.push(publications.join(', '));
-                    }
+                    if (publications)
+                        output.push(publications);
+                    if (options)
+                        output.push('WITH', options);
+                    break;
+                case 'ALTER_SUBSCRIPTION_ADD_PUBLICATION':
+                    output.push('ADD PUBLICATION');
+                    if (publications)
+                        output.push(publications);
+                    if (options)
+                        output.push('WITH', options);
+                    break;
+                case 'ALTER_SUBSCRIPTION_DROP_PUBLICATION':
+                    output.push('DROP PUBLICATION');
+                    if (publications)
+                        output.push(publications);
+                    if (options)
+                        output.push('WITH', options);
                     break;
                 case 'ALTER_SUBSCRIPTION_REFRESH':
                     output.push('REFRESH PUBLICATION');
+                    if (options)
+                        output.push('WITH', options);
                     break;
-                case 'ALTER_SUBSCRIPTION_ENABLED':
-                    output.push('ENABLE');
+                case 'ALTER_SUBSCRIPTION_ENABLED': {
+                    const enabled = list_utils_1.ListUtils.unwrapList(node.options).find(opt => opt.DefElem?.defname === 'enabled');
+                    const arg = enabled?.DefElem?.arg;
+                    const isEnabled = arg?.Boolean ? arg.Boolean.boolval !== false : true;
+                    output.push(isEnabled ? 'ENABLE' : 'DISABLE');
                     break;
+                }
                 case 'ALTER_SUBSCRIPTION_SKIP':
                     output.push('SKIP');
+                    if (options)
+                        output.push(options);
                     break;
                 default:
                     throw new Error(`Unsupported AlterSubscriptionStmt kind: ${node.kind}`);
             }
         }
-        if (node.options && node.options.length > 0) {
-            output.push('WITH');
-            const options = list_utils_1.ListUtils.unwrapList(node.options).map(opt => this.visit(opt, context));
-            output.push(`(${options.join(', ')})`);
-        }
         return output.join(' ');
     }
     DropSubscriptionStmt(node, context) {
@@ -8016,6 +8116,9 @@ class Deparser {
         if (node.grant_option && node.is_grant) {
             output.push('WITH GRANT OPTION');
         }
+        if (node.grantor) {
+            output.push('GRANTED BY', this.RoleSpec(node.grantor, context));
+        }
         // Only add behavior clauses for REVOKE statements, not for GRANT statements in ALTER DEFAULT PRIVILEGES
         if (!node.is_grant) {
             if (node.behavior === 'DROP_CASCADE') {
@@ -8029,57 +8132,34 @@ class Deparser {
     }
     GrantRoleStmt(node, context) {
         const output = [];
-        // Check for inherit, admin, and set options first to place them correctly
-        let hasInheritOption = false;
-        let hasAdminOption = false;
-        let hasSetOption = false;
-        let inheritValue;
-        let adminValue;
-        let setValue;
-        if (node.opt && node.opt.length > 0) {
-            const options = list_utils_1.ListUtils.unwrapList(node.opt);
-            const inheritOption = options.find(opt => opt.DefElem && opt.DefElem.defname === 'inherit');
-            const adminOption = options.find(opt => (opt.String && opt.String.sval === 'admin') ||
-                (opt.DefElem && opt.DefElem.defname === 'admin'));
-            const setOption = options.find(opt => opt.DefElem && opt.DefElem.defname === 'set');
-            if (inheritOption && inheritOption.DefElem) {
-                hasInheritOption = true;
-                inheritValue = inheritOption.DefElem.arg?.Boolean?.boolval;
-            }
-            if (adminOption) {
-                hasAdminOption = true;
-                if (adminOption.DefElem && adminOption.DefElem.arg) {
-                    adminValue = adminOption.DefElem.arg.Boolean?.boolval;
-                }
-            }
-            if (setOption && setOption.DefElem) {
-                hasSetOption = true;
-                setValue = setOption.DefElem.arg?.Boolean?.boolval;
-            }
-        }
+        const options = list_utils_1.ListUtils.unwrapList(node.opt)
+            .map(opt => opt.DefElem)
+            .filter((opt) => !!opt && !!opt.defname);
+        const optionValue = (opt) => {
+            if (!opt.arg)
+                return true;
+            const argType = this.getNodeType(opt.arg);
+            const argData = this.getNodeData(opt.arg);
+            if (argType === 'Boolean')
+                return argData.boolval !== false;
+            if (argType === 'String')
+                return argData.sval !== 'false';
+            return true;
+        };
+        const roles = list_utils_1.ListUtils.unwrapList(node.granted_roles)
+            .map(role => role.AccessPriv?.priv_name
+            ? quotes_1.QuoteUtils.quoteIdentifier(role.AccessPriv.priv_name)
+            : this.visit(role, context))
+            .join(', ');
         if (node.is_grant) {
-            output.push('GRANT');
+            output.push('GRANT', roles, 'TO');
         }
         else {
             output.push('REVOKE');
-            if (hasInheritOption) {
-                output.push('INHERIT OPTION FOR');
-            }
-            else if (hasAdminOption) {
-                output.push('ADMIN OPTION FOR');
+            if (options.length > 0) {
+                output.push(`${options[0].defname.toUpperCase()} OPTION FOR`);
             }
-        }
-        if (node.granted_roles && node.granted_roles.length > 0) {
-            const roles = list_utils_1.ListUtils.unwrapList(node.granted_roles)
-                .map(role => this.visit(role, context))
-                .join(', ');
-            output.push(roles);
-        }
-        if (node.is_grant) {
-            output.push('TO');
-        }
-        else {
-            output.push('FROM');
+            output.push(roles, 'FROM');
         }
         if (node.grantee_roles && node.grantee_roles.length > 0) {
             const grantees = list_utils_1.ListUtils.unwrapList(node.grantee_roles)
@@ -8087,38 +8167,15 @@ class Deparser {
                 .join(', ');
             output.push(grantees);
         }
-        if (node.is_grant) {
-            const withOptions = [];
-            if (hasAdminOption) {
-                if (adminValue === true) {
-                    withOptions.push('ADMIN OPTION');
-                }
-                else if (adminValue === false) {
-                    withOptions.push('ADMIN FALSE');
-                }
-                else {
-                    withOptions.push('ADMIN OPTION');
-                }
-            }
-            if (hasInheritOption) {
-                if (inheritValue === true) {
-                    withOptions.push('INHERIT OPTION');
-                }
-                else if (inheritValue === false) {
-                    withOptions.push('INHERIT FALSE');
-                }
-            }
-            if (hasSetOption) {
-                if (setValue === true) {
-                    withOptions.push('SET TRUE');
-                }
-                else if (setValue === false) {
-                    withOptions.push('SET FALSE');
-                }
-            }
-            if (withOptions.length > 0) {
-                output.push('WITH', withOptions.join(', '));
-            }
+        if (node.is_grant && options.length > 0) {
+            const withOptions = options.map(opt => `${opt.defname.toUpperCase()} ${optionValue(opt) ? 'TRUE' : 'FALSE'}`);
+            output.push('WITH', withOptions.join(', '));
+        }
+        if (node.grantor) {
+            output.push('GRANTED BY', this.RoleSpec(node.grantor, context));
+        }
+        if (!node.is_grant && node.behavior === 'DROP_CASCADE') {
+            output.push('CASCADE');
         }
         return output.join(' ');
     }
@@ -8698,10 +8755,9 @@ class Deparser {
         switch (node.commandType) {
             case 'CMD_UPDATE': {
                 output.push('UPDATE SET');
-                const assignments = list_utils_1.ListUtils.unwrapList(node.targetList)
-                    .map(target => this.visit(target, context.spawn('UpdateStmt', { update: true })))
-                    .join(', ');
-                output.push(assignments);
+                if (node.targetList && node.targetList.length > 0) {
+                    output.push(this.formatUpdateAssignments(node.targetList, context));
+                }
                 break;
             }
             case 'CMD_INSERT': {
@@ -9106,6 +9162,13 @@ class Deparser {
             output.push('USING');
             output.push(node.into.accessMethod);
         }
+        if (node.into && node.into.options && node.into.options.length > 0) {
+            output.push('WITH');
+            const options = list_utils_1.ListUtils.unwrapList(node.into.options)
+                .map(option => this.visit(option, context.spawn('CreateStmt')))
+                .join(', ');
+            output.push(`(${options})`);
+        }
         if (node.into && node.into.onCommit && node.into.onCommit !== 'ONCOMMIT_NOOP') {
             output.push('ON COMMIT');
             switch (node.into.onCommit) {
@@ -9120,17 +9183,13 @@ class Deparser {
                     break;
             }
         }
+        if (node.into && node.into.tableSpaceName) {
+            output.push('TABLESPACE', quotes_1.QuoteUtils.quoteIdentifier(node.into.tableSpaceName));
+        }
         output.push('AS');
         if (node.query) {
             output.push(this.visit(node.query, context));
         }
-        if (node.into && node.into.options && node.into.options.length > 0) {
-            output.push('WITH');
-            const options = list_utils_1.ListUtils.unwrapList(node.into.options)
-                .map(option => this.visit(option, context))
-                .join(', ');
-            output.push(`(${options})`);
-        }
         if (node.into && node.into.skipData) {
             output.push('WITH NO DATA');
         }
@@ -9603,7 +9662,7 @@ class Deparser {
         }
         if (node.whereClause) {
             output.push('WHERE');
-            output.push(this.visit(node.whereClause, context));
+            output.push(`(${this.visit(node.whereClause, context)})`);
         }
         return output.join(' ');
     }
@@ -9846,24 +9905,182 @@ class Deparser {
         }
         return output.join(' ');
     }
+    formatJsonFormat(format) {
+        if (!format || !format.format_type || format.format_type === 'JS_FORMAT_DEFAULT') {
+            return null;
+        }
+        const parts = ['FORMAT JSON'];
+        switch (format.encoding) {
+            case 'JS_ENC_UTF8':
+                parts.push('ENCODING UTF8');
+                break;
+            case 'JS_ENC_UTF16':
+                parts.push('ENCODING UTF16');
+                break;
+            case 'JS_ENC_UTF32':
+                parts.push('ENCODING UTF32');
+                break;
+        }
+        return parts.join(' ');
+    }
+    formatJsonOutput(output, context) {
+        if (!output || !output.typeName)
+            return null;
+        const parts = ['RETURNING', this.TypeName(output.typeName, context)];
+        const format = this.formatJsonFormat(output.returning?.format);
+        if (format)
+            parts.push(format);
+        return parts.join(' ');
+    }
+    formatJsonNullClause(absentOnNull) {
+        return absentOnNull ? 'ABSENT ON NULL' : 'NULL ON NULL';
+    }
+    formatJsonUniqueClause(unique) {
+        return unique ? 'WITH UNIQUE KEYS' : null;
+    }
+    JsonValueExpr(node, context) {
+        const parts = [];
+        if (node.raw_expr) {
+            parts.push(this.visit(node.raw_expr, context));
+        }
+        const format = this.formatJsonFormat(node.format);
+        if (format)
+            parts.push(format);
+        return parts.join(' ');
+    }
+    JsonKeyValue(node, context) {
+        const key = node.key ? this.visit(node.key, context) : '';
+        const value = node.value ? this.JsonValueExpr(node.value, context) : '';
+        return `${key} : ${value}`;
+    }
+    JsonObjectConstructor(node, context) {
+        const args = [];
+        if (node.exprs && node.exprs.length > 0) {
+            args.push(list_utils_1.ListUtils.unwrapList(node.exprs).map(e => this.visit(e, context)).join(', '));
+            args.push(this.formatJsonNullClause(node.absent_on_null));
+            const unique = this.formatJsonUniqueClause(node.unique);
+            if (unique)
+                args.push(unique);
+        }
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_OBJECT(${args.join(' ')})`;
+    }
+    JsonArrayConstructor(node, context) {
+        const args = [];
+        if (node.exprs && node.exprs.length > 0) {
+            args.push(list_utils_1.ListUtils.unwrapList(node.exprs).map(e => this.visit(e, context)).join(', '));
+            args.push(this.formatJsonNullClause(node.absent_on_null));
+        }
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_ARRAY(${args.join(' ')})`;
+    }
     JsonArrayQueryConstructor(node, context) {
-        const output = ['JSON_ARRAYAGG'];
+        const args = [];
         if (node.query) {
-            output.push(`(${this.visit(node.query, context)})`);
+            args.push(this.visit(node.query, context));
+        }
+        const format = this.formatJsonFormat(node.format);
+        if (format)
+            args.push(format);
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_ARRAY(${args.join(' ')})`;
+    }
+    formatJsonAggSuffix(ctor, context) {
+        if (!ctor)
+            return '';
+        let result = '';
+        if (ctor.agg_filter) {
+            result += ` FILTER (WHERE ${this.visit(ctor.agg_filter, context)})`;
         }
-        if (node.format) {
-            output.push('FORMAT JSON');
+        if (ctor.over) {
+            result += this.formatOverClause(ctor.over, context);
         }
-        if (node.output) {
-            output.push('RETURNING TEXT');
+        return result;
+    }
+    JsonObjectAgg(node, context) {
+        const args = [];
+        if (node.arg) {
+            args.push(this.JsonKeyValue(node.arg, context));
+        }
+        args.push(this.formatJsonNullClause(node.absent_on_null));
+        const unique = this.formatJsonUniqueClause(node.unique);
+        if (unique)
+            args.push(unique);
+        const output = this.formatJsonOutput(node.constructor?.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_OBJECTAGG(${args.join(' ')})${this.formatJsonAggSuffix(node.constructor, context)}`;
+    }
+    JsonArrayAgg(node, context) {
+        const args = [];
+        if (node.arg) {
+            args.push(this.JsonValueExpr(node.arg, context));
         }
-        if (node.absent_on_null) {
-            output.push('ABSENT ON NULL');
+        const aggOrder = node.constructor?.agg_order;
+        if (aggOrder && aggOrder.length > 0) {
+            const orderItems = list_utils_1.ListUtils.unwrapList(aggOrder).map(item => this.visit(item, context));
+            args.push(`ORDER BY ${orderItems.join(', ')}`);
         }
-        else {
-            output.push('NULL ON NULL');
+        args.push(this.formatJsonNullClause(node.absent_on_null));
+        const output = this.formatJsonOutput(node.constructor?.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_ARRAYAGG(${args.join(' ')})${this.formatJsonAggSuffix(node.constructor, context)}`;
+    }
+    JsonParseExpr(node, context) {
+        const args = [];
+        if (node.expr) {
+            args.push(this.JsonValueExpr(node.expr, context));
         }
-        return output.join(' ');
+        const unique = this.formatJsonUniqueClause(node.unique_keys);
+        if (unique)
+            args.push(unique);
+        return `JSON(${args.join(' ')})`;
+    }
+    JsonScalarExpr(node, context) {
+        const expr = node.expr ? this.visit(node.expr, context) : '';
+        return `JSON_SCALAR(${expr})`;
+    }
+    JsonSerializeExpr(node, context) {
+        const args = [];
+        if (node.expr) {
+            args.push(this.JsonValueExpr(node.expr, context));
+        }
+        const output = this.formatJsonOutput(node.output, context);
+        if (output)
+            args.push(output);
+        return `JSON_SERIALIZE(${args.join(' ')})`;
+    }
+    JsonIsPredicate(node, context) {
+        const parts = [];
+        if (node.expr) {
+            parts.push(this.visit(node.expr, context));
+        }
+        const format = this.formatJsonFormat(node.format);
+        if (format)
+            parts.push(format);
+        parts.push('IS JSON');
+        switch (node.item_type) {
+            case 'JS_TYPE_OBJECT':
+                parts.push('OBJECT');
+                break;
+            case 'JS_TYPE_ARRAY':
+                parts.push('ARRAY');
+                break;
+            case 'JS_TYPE_SCALAR':
+                parts.push('SCALAR');
+                break;
+        }
+        if (node.unique_keys) {
+            parts.push('WITH UNIQUE KEYS');
+        }
+        return parts.join(' ');
     }
     RangeFunction(node, context) {
         const output = [];