rawsql-ts 0.11.42-beta → 0.11.44-beta

package/dist/esm/src/parsers/SqlPrintTokenParser.js

@@ -1,4 +1,4 @@
-import { PartitionByClause, OrderByClause, OrderByItem, SelectClause, SelectItem, Distinct, DistinctOn, SortDirection, NullsSortDirection, TableSource, SourceExpression, FromClause, JoinClause, JoinOnClause, JoinUsingClause, FunctionSource, SourceAliasExpression, WhereClause, GroupByClause, HavingClause, SubQuerySource, WindowFrameClause, LimitClause, ForClause, OffsetClause, WindowsClause as WindowClause, CommonTable, WithClause, FetchClause, FetchExpression, InsertClause, UpdateClause, SetClause, ReturningClause, SetClauseItem } from "../models/Clause";
+import { PartitionByClause, OrderByClause, OrderByItem, SelectClause, SelectItem, Distinct, DistinctOn, SortDirection, NullsSortDirection, TableSource, SourceExpression, FromClause, JoinClause, JoinOnClause, JoinUsingClause, FunctionSource, SourceAliasExpression, WhereClause, GroupByClause, HavingClause, SubQuerySource, WindowFrameClause, LimitClause, ForClause, OffsetClause, WindowsClause as WindowClause, CommonTable, WithClause, FetchClause, FetchExpression, InsertClause, UpdateClause, DeleteClause, UsingClause, SetClause, ReturningClause, SetClauseItem } from "../models/Clause";
 import { HintClause } from "../models/HintClause";
 import { BinarySelectQuery, SimpleSelectQuery, ValuesQuery } from "../models/SelectQuery";
 import { SqlPrintToken, SqlPrintTokenType, SqlPrintTokenContainerType } from "../models/SqlPrintToken";
@@ -8,7 +8,10 @@ import { IdentifierDecorator } from "./IdentifierDecorator";
 import { ParameterDecorator } from "./ParameterDecorator";
 import { InsertQuery } from "../models/InsertQuery";
 import { UpdateQuery } from "../models/UpdateQuery";
-import { CreateTableQuery } from "../models/CreateTableQuery";
+import { DeleteQuery } from "../models/DeleteQuery";
+import { CreateTableQuery, TableColumnDefinition, ColumnConstraintDefinition, TableConstraintDefinition, ReferenceDefinition } from "../models/CreateTableQuery";
+import { MergeQuery, MergeWhenClause, MergeUpdateAction, MergeDeleteAction, MergeInsertAction, MergeDoNothingAction } from "../models/MergeQuery";
+import { DropTableStatement, DropIndexStatement, CreateIndexStatement, IndexColumnDefinition, AlterTableStatement, AlterTableAddConstraint, AlterTableDropConstraint, AlterTableDropColumn, DropConstraintStatement } from "../models/DDLStatements";
 export var ParameterStyle;
 (function (ParameterStyle) {
     ParameterStyle["Anonymous"] = "anonymous";
@@ -20,36 +23,45 @@ export const PRESETS = {
         identifierEscape: { start: '`', end: '`' },
         parameterSymbol: '?',
         parameterStyle: ParameterStyle.Anonymous,
+        constraintStyle: 'mysql',
     },
     postgres: {
         identifierEscape: { start: '"', end: '"' },
         parameterSymbol: '$',
         parameterStyle: ParameterStyle.Indexed,
+        castStyle: 'postgres',
+        constraintStyle: 'postgres',
     },
     postgresWithNamedParams: {
         identifierEscape: { start: '"', end: '"' },
         parameterSymbol: ':',
         parameterStyle: ParameterStyle.Named,
+        castStyle: 'postgres',
+        constraintStyle: 'postgres',
     },
     sqlserver: {
         identifierEscape: { start: '[', end: ']' },
         parameterSymbol: '@',
         parameterStyle: ParameterStyle.Named,
+        constraintStyle: 'postgres',
     },
     sqlite: {
         identifierEscape: { start: '"', end: '"' },
         parameterSymbol: ':',
         parameterStyle: ParameterStyle.Named,
+        constraintStyle: 'postgres',
     },
     oracle: {
         identifierEscape: { start: '"', end: '"' },
         parameterSymbol: ':',
         parameterStyle: ParameterStyle.Named,
+        constraintStyle: 'postgres',
     },
     clickhouse: {
         identifierEscape: { start: '`', end: '`' },
         parameterSymbol: '?',
         parameterStyle: ParameterStyle.Anonymous,
+        constraintStyle: 'postgres',
     },
     firebird: {
         identifierEscape: { start: '"', end: '"' },
@@ -80,6 +92,7 @@ export const PRESETS = {
         identifierEscape: { start: '"', end: '"' },
         parameterSymbol: '$',
         parameterStyle: ParameterStyle.Indexed,
+        castStyle: 'postgres',
     },
     athena: {
         identifierEscape: { start: '"', end: '"' },
@@ -105,6 +118,7 @@ export const PRESETS = {
         identifierEscape: { start: '"', end: '"' },
         parameterSymbol: '$',
         parameterStyle: ParameterStyle.Indexed,
+        castStyle: 'postgres',
     },
     flinksql: {
         identifierEscape: { start: '`', end: '`' },
@@ -139,10 +153,10 @@ export class SqlPrintTokenParser {
         return this._selfHandlingComponentTypes;
     }
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         this.handlers = new Map();
         this.index = 1;
-        this.commentStyle = 'block';
+        this.joinConditionContexts = [];
         if (options === null || options === void 0 ? void 0 : options.preset) {
             const preset = options.preset;
             options = Object.assign(Object.assign({}, preset), options);
@@ -156,7 +170,9 @@ export class SqlPrintTokenParser {
             start: (_e = (_d = options === null || options === void 0 ? void 0 : options.identifierEscape) === null || _d === void 0 ? void 0 : _d.start) !== null && _e !== void 0 ? _e : '"',
             end: (_g = (_f = options === null || options === void 0 ? void 0 : options.identifierEscape) === null || _f === void 0 ? void 0 : _f.end) !== null && _g !== void 0 ? _g : '"'
         });
-        this.commentStyle = (_h = options === null || options === void 0 ? void 0 : options.commentStyle) !== null && _h !== void 0 ? _h : 'block';
+        this.castStyle = (_h = options === null || options === void 0 ? void 0 : options.castStyle) !== null && _h !== void 0 ? _h : 'standard';
+        this.constraintStyle = (_j = options === null || options === void 0 ? void 0 : options.constraintStyle) !== null && _j !== void 0 ? _j : 'postgres';
+        this.normalizeJoinConditionOrder = (_k = options === null || options === void 0 ? void 0 : options.joinConditionOrderByDeclaration) !== null && _k !== void 0 ? _k : false;
         this.handlers.set(ValueList.kind, (expr) => this.visitValueList(expr));
         this.handlers.set(ColumnReference.kind, (expr) => this.visitColumnReference(expr));
         this.handlers.set(QualifiedName.kind, (expr) => this.visitQualifiedName(expr));
@@ -228,10 +244,32 @@ export class SqlPrintTokenParser {
         this.handlers.set(InsertClause.kind, (expr) => this.visitInsertClause(expr));
         this.handlers.set(UpdateQuery.kind, (expr) => this.visitUpdateQuery(expr));
         this.handlers.set(UpdateClause.kind, (expr) => this.visitUpdateClause(expr));
+        this.handlers.set(DeleteQuery.kind, (expr) => this.visitDeleteQuery(expr));
+        this.handlers.set(DeleteClause.kind, (expr) => this.visitDeleteClause(expr));
+        this.handlers.set(UsingClause.kind, (expr) => this.visitUsingClause(expr));
         this.handlers.set(SetClause.kind, (expr) => this.visitSetClause(expr));
         this.handlers.set(SetClauseItem.kind, (expr) => this.visitSetClauseItem(expr));
         this.handlers.set(ReturningClause.kind, (expr) => this.visitReturningClause(expr));
         this.handlers.set(CreateTableQuery.kind, (expr) => this.visitCreateTableQuery(expr));
+        this.handlers.set(TableColumnDefinition.kind, (expr) => this.visitTableColumnDefinition(expr));
+        this.handlers.set(ColumnConstraintDefinition.kind, (expr) => this.visitColumnConstraintDefinition(expr));
+        this.handlers.set(TableConstraintDefinition.kind, (expr) => this.visitTableConstraintDefinition(expr));
+        this.handlers.set(ReferenceDefinition.kind, (expr) => this.visitReferenceDefinition(expr));
+        this.handlers.set(CreateIndexStatement.kind, (expr) => this.visitCreateIndexStatement(expr));
+        this.handlers.set(IndexColumnDefinition.kind, (expr) => this.visitIndexColumnDefinition(expr));
+        this.handlers.set(DropTableStatement.kind, (expr) => this.visitDropTableStatement(expr));
+        this.handlers.set(DropIndexStatement.kind, (expr) => this.visitDropIndexStatement(expr));
+        this.handlers.set(AlterTableStatement.kind, (expr) => this.visitAlterTableStatement(expr));
+        this.handlers.set(AlterTableAddConstraint.kind, (expr) => this.visitAlterTableAddConstraint(expr));
+        this.handlers.set(AlterTableDropConstraint.kind, (expr) => this.visitAlterTableDropConstraint(expr));
+        this.handlers.set(AlterTableDropColumn.kind, (expr) => this.visitAlterTableDropColumn(expr));
+        this.handlers.set(DropConstraintStatement.kind, (expr) => this.visitDropConstraintStatement(expr));
+        this.handlers.set(MergeQuery.kind, (expr) => this.visitMergeQuery(expr));
+        this.handlers.set(MergeWhenClause.kind, (expr) => this.visitMergeWhenClause(expr));
+        this.handlers.set(MergeUpdateAction.kind, (expr) => this.visitMergeUpdateAction(expr));
+        this.handlers.set(MergeDeleteAction.kind, (expr) => this.visitMergeDeleteAction(expr));
+        this.handlers.set(MergeInsertAction.kind, (expr) => this.visitMergeInsertAction(expr));
+        this.handlers.set(MergeDoNothingAction.kind, (expr) => this.visitMergeDoNothingAction(expr));
     }
     /**
      * Pretty-prints a BinarySelectQuery (e.g., UNION, INTERSECT, EXCEPT).
@@ -247,14 +285,12 @@ export class SqlPrintTokenParser {
             arg.positionedComments = null;
         }
         else if (arg.headerComments && arg.headerComments.length > 0) {
-            // Fallback to legacy headerComments if no positioned comments
-            // For smart comment style, treat headerComments as a single multi-line block
-            if (this.commentStyle === 'smart' && arg.headerComments.length > 1) {
+            if (this.shouldMergeHeaderComments(arg.headerComments)) {
                 const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
                 token.innerTokens.push(mergedHeaderComment);
             }
             else {
-                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
+                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments, true);
                 token.innerTokens.push(...headerCommentBlocks);
             }
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
@@ -438,14 +474,9 @@ export class SqlPrintTokenParser {
         const beforeComments = component.getPositionedComments('before');
         if (beforeComments.length > 0) {
             const commentBlocks = this.createCommentBlocks(beforeComments);
-            // Create a single inline sequence: /* comment */ content
-            const beforeTokens = [];
-            for (const commentBlock of commentBlocks) {
-                beforeTokens.push(commentBlock);
-                beforeTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+            for (let i = commentBlocks.length - 1; i >= 0; i--) {
+                token.innerTokens.unshift(commentBlocks[i]);
             }
-            // Insert before the existing content
-            token.innerTokens.unshift(...beforeTokens);
         }
         // Handle 'after' comments - add inline after the main content
         const afterComments = component.getPositionedComments('after');
@@ -453,7 +484,7 @@ export class SqlPrintTokenParser {
             const commentBlocks = this.createCommentBlocks(afterComments);
             // Append after comments with spaces for inline formatting
             for (const commentBlock of commentBlocks) {
-                token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
                 token.innerTokens.push(commentBlock);
             }
         }
@@ -482,16 +513,8 @@ export class SqlPrintTokenParser {
         if (!(comments === null || comments === void 0 ? void 0 : comments.length)) {
             return;
         }
-        // For multiple comments, create inline comment sequence instead of separate blocks
-        if (comments.length > 1) {
-            const inlineComments = this.createInlineCommentSequence(comments);
-            this.insertCommentBlocksWithSpacing(token, inlineComments);
-        }
-        else {
-            // Create CommentBlock containers for single comment
-            const commentBlocks = this.createCommentBlocks(comments);
-            this.insertCommentBlocksWithSpacing(token, commentBlocks);
-        }
+        const commentBlocks = this.createCommentBlocks(comments);
+        this.insertCommentBlocksWithSpacing(token, commentBlocks);
     }
     /**
      * Creates inline comment sequence for multiple comments without newlines
@@ -502,7 +525,7 @@ export class SqlPrintTokenParser {
             const comment = comments[i];
             if (comment.trim()) {
                 // Add comment token directly
-                const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatBlockComment(comment));
+                const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatComment(comment));
                 commentTokens.push(commentToken);
                 // Add space between comments (except after last comment)
                 if (i < comments.length - 1) {
@@ -515,63 +538,21 @@ export class SqlPrintTokenParser {
     }
     /**
      * Creates CommentBlock containers for the given comments.
-     * Each CommentBlock contains: Comment -> CommentNewline -> Space
-     * This structure supports both oneliner and multiline formatting modes.
+     * Each CommentBlock contains: Comment -> CommentNewline -> Space.
+     * @param comments Raw comment strings to convert into CommentBlock tokens.
+     * @param isHeaderComment Marks the generated blocks as originating from header comments when true.
      */
-    createCommentBlocks(comments) {
-        if (this.commentStyle === 'smart') {
-            return this.createSmartCommentBlocks(comments);
-        }
-        // Block style (default) - each comment gets its own block
+    createCommentBlocks(comments, isHeaderComment = false) {
+        // Create individual comment blocks for each comment entry
         const commentBlocks = [];
         for (const comment of comments) {
             // Accept comments that have content after trim OR are separator lines OR are empty (for structure preservation)
             const trimmed = comment.trim();
             const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
             if (trimmed || isSeparatorLine || comment === '') {
-                commentBlocks.push(this.createSingleCommentBlock(comment));
-            }
-        }
-        return commentBlocks;
-    }
-    /**
-     * Creates smart comment blocks by merging consecutive block comments into multi-line format
-     */
-    createSmartCommentBlocks(comments) {
-        const commentBlocks = [];
-        const blockComments = [];
-        const flushBlockComments = () => {
-            if (blockComments.length > 0) {
-                if (blockComments.length === 1) {
-                    // Single comment - keep as-is
-                    commentBlocks.push(this.createSingleCommentBlock(blockComments[0]));
-                }
-                else {
-                    // Multiple consecutive comments - create multi-line block
-                    commentBlocks.push(this.createMultiLineCommentBlock(blockComments));
-                }
-                blockComments.length = 0;
-            }
-        };
-        for (const comment of comments) {
-            const trimmed = comment.trim();
-            const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
-            if (!trimmed && !isSeparatorLine && comment !== '') {
-                continue;
-            }
-            // Check if this is a block comment that should be merged
-            if (this.shouldMergeComment(trimmed)) {
-                blockComments.push(comment);
-            }
-            else {
-                // Flush any accumulated block comments first
-                flushBlockComments();
-                // Add this comment as-is
-                commentBlocks.push(this.createSingleCommentBlock(comment));
+                commentBlocks.push(this.createSingleCommentBlock(comment, isHeaderComment));
             }
         }
-        // Flush any remaining block comments
-        flushBlockComments();
         return commentBlocks;
     }
     /**
@@ -584,8 +565,14 @@ export class SqlPrintTokenParser {
             return false;
         }
         // Don't merge if it's already a proper multi-line block comment
-        if (trimmed.startsWith('/*') && trimmed.endsWith('*/') && trimmed.includes('\n')) {
-            return false;
+        if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
+            const inner = trimmed.slice(2, -2).trim();
+            if (!inner) {
+                return false;
+            }
+            if (trimmed.includes('\n')) {
+                return false;
+            }
         }
         // Merge all other content including separator lines, plain text, and single-line block comments
         // Separator lines within comment blocks should be merged together
@@ -595,98 +582,6 @@ export class SqlPrintTokenParser {
      * Creates a multi-line block comment structure from consecutive comments
      * Returns a CommentBlock containing multiple comment lines for proper LinePrinter integration
      */
-    createMultiLineCommentBlock(comments) {
-        const lines = [];
-        for (const comment of comments) {
-            const trimmed = comment.trim();
-            // Remove existing /* */ markers if present and extract content
-            if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
-                const content = trimmed.slice(2, -2);
-                if (content.trim()) {
-                    // Sanitize the content (only remove /* and */)
-                    const sanitized = content
-                        .replace(/\*\//g, '*') // Remove */ sequences
-                        .replace(/\/\*/g, '*'); // Remove /* sequences
-                    // Split multi-line content and add each line
-                    const contentLines = sanitized.split('\n').map(line => line.trim()).filter(line => line);
-                    lines.push(...contentLines);
-                }
-            }
-            else if (trimmed) {
-                // Sanitize plain text content
-                const sanitized = trimmed
-                    .replace(/\*\//g, '*') // Remove */ sequences
-                    .replace(/\/\*/g, '*'); // Remove /* sequences
-                // Split plain text content by lines
-                const contentLines = sanitized.split('\n').map(line => line.trim()).filter(line => line);
-                lines.push(...contentLines);
-            }
-        }
-        // Create multi-line comment block structure
-        const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
-        if (lines.length === 0) {
-            // Empty comment
-            const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, '/* */');
-            commentBlock.innerTokens.push(commentToken);
-        }
-        else {
-            // Opening /*
-            const openToken = new SqlPrintToken(SqlPrintTokenType.comment, '/*');
-            commentBlock.innerTokens.push(openToken);
-            commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
-            // Content lines (each as separate comment token)
-            for (const line of lines) {
-                const lineToken = new SqlPrintToken(SqlPrintTokenType.comment, `  ${line}`);
-                commentBlock.innerTokens.push(lineToken);
-                commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
-            }
-            // Closing */
-            const closeToken = new SqlPrintToken(SqlPrintTokenType.comment, '*/');
-            commentBlock.innerTokens.push(closeToken);
-        }
-        // Add final newline and space for standard structure
-        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
-        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
-        return commentBlock;
-    }
-    /**
-     * Creates a multi-line comment block specifically for headerComments
-     * headerComments come as pre-split lines, so we handle them differently
-     */
-    createHeaderMultiLineCommentBlock(headerComments) {
-        // Keep all lines including empty ones to preserve structure
-        const lines = headerComments;
-        // Create multi-line comment block structure
-        const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
-        if (lines.length === 0) {
-            // Empty comment
-            const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, '/* */');
-            commentBlock.innerTokens.push(commentToken);
-        }
-        else {
-            // Opening /*
-            const openToken = new SqlPrintToken(SqlPrintTokenType.comment, '/*');
-            commentBlock.innerTokens.push(openToken);
-            commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
-            // Content lines (each as separate comment token)
-            for (const line of lines) {
-                // Sanitize the line content
-                const sanitized = line
-                    .replace(/\*\//g, '*') // Remove */ sequences
-                    .replace(/\/\*/g, '*'); // Remove /* sequences
-                const lineToken = new SqlPrintToken(SqlPrintTokenType.comment, `  ${sanitized}`);
-                commentBlock.innerTokens.push(lineToken);
-                commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
-            }
-            // Closing */
-            const closeToken = new SqlPrintToken(SqlPrintTokenType.comment, '*/');
-            commentBlock.innerTokens.push(closeToken);
-        }
-        // Add final newline and space for standard structure
-        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
-        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
-        return commentBlock;
-    }
     /**
      * Creates a single CommentBlock with the standard structure:
      * Comment -> CommentNewline -> Space
@@ -695,8 +590,11 @@ export class SqlPrintTokenParser {
      * - Multiline mode: Comment + newline (space is filtered as leading space)
      * - Oneliner mode: Comment + space (commentNewline is skipped)
      */
-    createSingleCommentBlock(comment) {
+    createSingleCommentBlock(comment, isHeaderComment = false) {
         const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
+        if (isHeaderComment) {
+            commentBlock.markAsHeaderComment();
+        }
         // Add comment token - preserve original format for line comments
         const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, this.formatComment(comment));
         commentBlock.innerTokens.push(commentToken);
@@ -714,42 +612,28 @@ export class SqlPrintTokenParser {
      */
     formatComment(comment) {
         const trimmed = comment.trim();
-        // Smart style processing
-        if (this.commentStyle === 'smart') {
-            return this.formatCommentSmart(trimmed);
+        if (!trimmed) {
+            return '/* */';
         }
-        // Default block style processing
-        // If it's already a line comment, preserve it
-        // But exclude separator lines (lines with only dashes, equals, etc.)
-        if (trimmed.startsWith('--') && !/^--[-=_+*#]*$/.test(trimmed)) {
-            return trimmed;
+        const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
+        if (isSeparatorLine) {
+            return this.formatBlockComment(trimmed);
+        }
+        if (trimmed.startsWith('--')) {
+            return this.formatLineComment(trimmed.slice(2));
         }
-        // If it's already a block comment, preserve it (but sanitize)
         if (trimmed.startsWith('/*') && trimmed.endsWith('*/')) {
-            // Pass the entire comment including /* and */ for proper sanitization
             return this.formatBlockComment(trimmed);
         }
-        // For plain text comments, convert to block format
         return this.formatBlockComment(trimmed);
     }
-    /**
-     * Formats comments using smart style rules:
-     * - Only multi-line block comment merging is supported
-     * - Single-line comments remain as block comments (no dash conversion)
-     */
-    formatCommentSmart(comment) {
-        // Smart style only affects multi-line comment merging at createSmartCommentBlocks level
-        // Individual comment formatting remains the same as block style
-        return this.formatBlockComment(comment);
-    }
     /**
      * Inserts comment blocks into a token and handles spacing logic.
      * Adds separator spaces for clause-level containers and manages duplicate space removal.
      */
     insertCommentBlocksWithSpacing(token, commentBlocks) {
-        // For SelectItem, append comments at the end with proper spacing
+        // For SelectItem, append comment blocks after ensuring spacing
         if (token.containerType === SqlPrintTokenContainerType.SelectItem) {
-            // Add space before comment if not already present
             if (token.innerTokens.length > 0) {
                 const lastToken = token.innerTokens[token.innerTokens.length - 1];
                 if (lastToken.type !== SqlPrintTokenType.space) {
@@ -769,7 +653,6 @@ export class SqlPrintTokenParser {
         }
         // Special handling for IdentifierString to add space before comment
         if (token.containerType === SqlPrintTokenContainerType.IdentifierString) {
-            // Add space before comment if not already present
             if (token.innerTokens.length > 0) {
                 const lastToken = token.innerTokens[token.innerTokens.length - 1];
                 if (lastToken.type !== SqlPrintTokenType.space) {
@@ -872,27 +755,95 @@ export class SqlPrintTokenParser {
      * Prevents SQL injection by removing dangerous comment sequences.
      */
     formatBlockComment(comment) {
-        // Sanitize dangerous comment sequences to prevent SQL injection
-        let sanitizedComment = comment
-            .replace(/\*\//g, '*') // Remove comment close sequences
-            .replace(/\/\*/g, '*'); // Remove comment open sequences
-        // Check if this is a separator line (like ----------) before processing
-        const trimmed = sanitizedComment.trim();
-        const isSeparatorLine = /^[-=_+*#]+$/.test(trimmed);
-        if (isSeparatorLine) {
-            // For separator lines, preserve as-is (already sanitized above)
-            return `/* ${trimmed} */`;
-        }
-        // For multiline comments: convert newlines to spaces (security requirement)
-        sanitizedComment = sanitizedComment
-            .replace(/\r?\n/g, ' ') // Replace newlines with spaces
-            .replace(/\s+/g, ' ') // Collapse multiple spaces into single space
-            .trim(); // Remove leading/trailing whitespace
-        // Return empty string if comment becomes empty after sanitization
-        if (!sanitizedComment) {
-            return '';
+        const hasDelimiters = comment.startsWith('/*') && comment.endsWith('*/');
+        const rawContent = hasDelimiters ? comment.slice(2, -2) : comment;
+        const escapedContent = this.escapeCommentDelimiters(rawContent);
+        const normalized = escapedContent.replace(/\r?\n/g, '\n');
+        const lines = normalized
+            .split('\n')
+            .map(line => line.replace(/\s+/g, ' ').trim())
+            .filter(line => line.length > 0);
+        if (lines.length === 0) {
+            return '/* */';
+        }
+        const isSeparatorLine = lines.length === 1 && /^[-=_+*#]+$/.test(lines[0]);
+        if (!hasDelimiters) {
+            // Flatten free-form comments to a single block to avoid leaking multi-line structures.
+            if (isSeparatorLine) {
+                return `/* ${lines[0]} */`;
+            }
+            const flattened = lines.join(' ');
+            return `/* ${flattened} */`;
+        }
+        if (isSeparatorLine || lines.length === 1) {
+            return `/* ${lines[0]} */`;
+        }
+        const body = lines.map(line => `  ${line}`).join('\n');
+        return `/*\n${body}\n*/`;
+    }
+    shouldMergeHeaderComments(comments) {
+        if (comments.length <= 1) {
+            return false;
+        }
+        return comments.some(comment => {
+            const trimmed = comment.trim();
+            return /^[-=_+*#]{3,}$/.test(trimmed) || trimmed.startsWith('- ') || trimmed.startsWith('* ');
+        });
+    }
+    createHeaderMultiLineCommentBlock(headerComments) {
+        const commentBlock = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CommentBlock);
+        commentBlock.markAsHeaderComment();
+        if (headerComments.length === 0) {
+            const commentToken = new SqlPrintToken(SqlPrintTokenType.comment, '/* */');
+            commentBlock.innerTokens.push(commentToken);
+        }
+        else {
+            const openToken = new SqlPrintToken(SqlPrintTokenType.comment, '/*');
+            commentBlock.innerTokens.push(openToken);
+            commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            for (const line of headerComments) {
+                const sanitized = this.escapeCommentDelimiters(line);
+                const lineToken = new SqlPrintToken(SqlPrintTokenType.comment, `  ${sanitized}`);
+                commentBlock.innerTokens.push(lineToken);
+                commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            }
+            const closeToken = new SqlPrintToken(SqlPrintTokenType.comment, '*/');
+            commentBlock.innerTokens.push(closeToken);
+        }
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+        commentBlock.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.space, ' '));
+        return commentBlock;
+    }
+    /**
+     * Formats text as a single-line comment while sanitizing unsafe sequences.
+     */
+    formatLineComment(content) {
+        // Normalize content to a single line and remove dangerous sequences
+        const sanitized = this.sanitizeLineCommentContent(content);
+        if (!sanitized) {
+            return '--';
         }
-        return `/* ${sanitizedComment} */`;
+        return `-- ${sanitized}`;
+    }
+    /**
+     * Sanitizes content intended for a single-line comment.
+     */
+    sanitizeLineCommentContent(content) {
+        // Replace comment delimiters to avoid nested comment injection
+        let sanitized = this.escapeCommentDelimiters(content)
+            .replace(/\r?\n/g, ' ')
+            .replace(/\u2028|\u2029/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (sanitized.startsWith('--')) {
+            sanitized = sanitized.slice(2).trimStart();
+        }
+        return sanitized;
+    }
+    escapeCommentDelimiters(content) {
+        return content
+            .replace(/\/\*/g, '\\/\\*')
+            .replace(/\*\//g, '*\\/');
     }
     visitValueList(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ValueList);
@@ -912,7 +863,6 @@ export class SqlPrintTokenParser {
     }
     visitFunctionCall(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.FunctionCall);
-        this.addComponentComments(token, arg);
         token.innerTokens.push(arg.qualifiedName.accept(this));
         token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
         if (arg.argument) {
@@ -950,6 +900,7 @@ export class SqlPrintTokenParser {
                 token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
             }
         }
+        this.addComponentComments(token, arg);
         return token;
     }
     visitUnaryExpression(arg) {
@@ -1154,9 +1105,22 @@ export class SqlPrintTokenParser {
     }
     visitCastExpression(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CastExpression);
+        // Use PostgreSQL-specific :: casts only when the preset explicitly opts in.
+        if (this.castStyle === 'postgres') {
+            token.innerTokens.push(this.visit(arg.input));
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.operator, '::'));
+            token.innerTokens.push(this.visit(arg.castType));
+            return token;
+        }
+        // Default to ANSI-compliant CAST(expression AS type) syntax for broader compatibility.
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'cast'));
+        token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
         token.innerTokens.push(this.visit(arg.input));
-        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.operator, '::'));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'as'));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(this.visit(arg.castType));
+        token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
         return token;
     }
     visitCaseExpression(arg) {
@@ -1167,20 +1131,148 @@ export class SqlPrintTokenParser {
             // Clear positioned comments to prevent duplicate processing
             arg.positionedComments = null;
         }
+        const promotedComments = [];
+        const trailingSwitchComments = this.extractSwitchAfterComments(arg.switchCase);
+        let conditionToken = null;
+        if (arg.condition) {
+            conditionToken = this.visit(arg.condition);
+            promotedComments.push(...this.collectCaseLeadingCommentBlocks(conditionToken));
+        }
+        const switchToken = this.visit(arg.switchCase);
+        promotedComments.push(...this.collectCaseLeadingCommentsFromSwitch(switchToken));
+        if (promotedComments.length > 0) {
+            token.innerTokens.push(...promotedComments);
+        }
         // Add the CASE keyword
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'case'));
         // Add the condition if exists
-        if (arg.condition) {
+        if (conditionToken) {
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-            token.innerTokens.push(this.visit(arg.condition));
+            token.innerTokens.push(conditionToken);
         }
         // Add the WHEN/THEN pairs and ELSE
-        token.innerTokens.push(this.visit(arg.switchCase));
+        token.innerTokens.push(switchToken);
         // Add the END keyword
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'end'));
+        if (trailingSwitchComments.length > 0) {
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+            const trailingBlocks = this.createCommentBlocks(trailingSwitchComments);
+            token.innerTokens.push(...trailingBlocks);
+        }
         return token;
     }
+    extractSwitchAfterComments(arg) {
+        if (!arg.positionedComments || arg.positionedComments.length === 0) {
+            return [];
+        }
+        const trailing = [];
+        const retained = [];
+        for (const entry of arg.positionedComments) {
+            if (entry.position === 'after') {
+                trailing.push(...entry.comments);
+            }
+            else {
+                retained.push(entry);
+            }
+        }
+        arg.positionedComments = retained.length > 0 ? retained : null;
+        return trailing;
+    }
+    collectCaseLeadingCommentsFromSwitch(token) {
+        if (!token.innerTokens || token.innerTokens.length === 0) {
+            return [];
+        }
+        const pairToken = token.innerTokens.find(child => child.containerType === SqlPrintTokenContainerType.CaseKeyValuePair);
+        if (!pairToken) {
+            return [];
+        }
+        const keyToken = this.findCaseKeyToken(pairToken);
+        if (!keyToken) {
+            return [];
+        }
+        return this.collectCaseLeadingCommentBlocks(keyToken);
+    }
+    findCaseKeyToken(pairToken) {
+        for (const child of pairToken.innerTokens) {
+            if (child.containerType === SqlPrintTokenContainerType.CommentBlock) {
+                continue;
+            }
+            if (child.type === SqlPrintTokenType.space) {
+                continue;
+            }
+            if (child.type === SqlPrintTokenType.keyword) {
+                continue;
+            }
+            if (child.containerType === SqlPrintTokenContainerType.CaseThenValue) {
+                continue;
+            }
+            return child;
+        }
+        return undefined;
+    }
+    collectCaseLeadingCommentBlocks(token) {
+        if (!token.innerTokens || token.innerTokens.length === 0) {
+            return [];
+        }
+        const collected = [];
+        this.collectCaseLeadingCommentBlocksRecursive(token, collected, new Set(), 0);
+        return collected;
+    }
+    collectCaseLeadingCommentBlocksRecursive(token, collected, seen, depth) {
+        if (!token.innerTokens || token.innerTokens.length === 0) {
+            return;
+        }
+        let removedAny = false;
+        while (token.innerTokens.length > 0) {
+            const first = token.innerTokens[0];
+            if (first.containerType === SqlPrintTokenContainerType.CommentBlock) {
+                token.innerTokens.shift();
+                const signature = this.commentBlockSignature(first);
+                if (!(depth > 0 && seen.has(signature))) {
+                    collected.push(first);
+                    seen.add(signature);
+                }
+                removedAny = true;
+                continue;
+            }
+            if (!removedAny && first.type === SqlPrintTokenType.space) {
+                return;
+            }
+            break;
+        }
+        if (!token.innerTokens || token.innerTokens.length === 0) {
+            return;
+        }
+        const firstChild = token.innerTokens[0];
+        if (this.isTransparentCaseWrapper(firstChild)) {
+            this.collectCaseLeadingCommentBlocksRecursive(firstChild, collected, seen, depth + 1);
+        }
+    }
+    isTransparentCaseWrapper(token) {
+        if (!token) {
+            return false;
+        }
+        const transparentContainers = [
+            SqlPrintTokenContainerType.ColumnReference,
+            SqlPrintTokenContainerType.QualifiedName,
+            SqlPrintTokenContainerType.IdentifierString,
+            SqlPrintTokenContainerType.RawString,
+            SqlPrintTokenContainerType.LiteralValue,
+            SqlPrintTokenContainerType.ParenExpression,
+            SqlPrintTokenContainerType.UnaryExpression,
+        ];
+        return transparentContainers.includes(token.containerType);
+    }
+    commentBlockSignature(commentBlock) {
+        if (!commentBlock.innerTokens || commentBlock.innerTokens.length === 0) {
+            return '';
+        }
+        return commentBlock.innerTokens
+            .filter(inner => inner.text !== '')
+            .map(inner => inner.text)
+            .join('|');
+    }
     visitArrayExpression(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ArrayExpression);
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'array'));
@@ -1266,6 +1358,7 @@ export class SqlPrintTokenParser {
     }
     visitTupleExpression(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.TupleExpression);
+        const requiresMultiline = this.tupleRequiresMultiline(arg);
         token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
         for (let i = 0; i < arg.values.length; i++) {
             if (i > 0) {
@@ -1273,10 +1366,38 @@ export class SqlPrintTokenParser {
             }
             token.innerTokens.push(this.visit(arg.values[i]));
         }
+        if (requiresMultiline) {
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, '', SqlPrintTokenContainerType.TupleExpression));
+        }
         token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
-        this.addComponentComments(token, arg);
         return token;
     }
+    tupleRequiresMultiline(tuple) {
+        for (const value of tuple.values) {
+            if (this.hasInlineComments(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasInlineComments(component) {
+        if (this.hasLeadingComments(component)) {
+            return true;
+        }
+        if (component instanceof TupleExpression) {
+            return this.tupleRequiresMultiline(component);
+        }
+        return false;
+    }
+    hasLeadingComments(component) {
+        var _a;
+        const positioned = (_a = component.positionedComments) !== null && _a !== void 0 ? _a : [];
+        const before = positioned.find(pc => pc.position === 'before');
+        if (before && before.comments.some(comment => comment.trim().length > 0)) {
+            return true;
+        }
+        return false;
+    }
     visitWindowFrameExpression(arg) {
         // Compose window frame expression: over(partition by ... order by ... rows ...)
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.WindowFrameExpression);
@@ -1355,19 +1476,16 @@ export class SqlPrintTokenParser {
         const originalValuePositionedComments = arg.value.positionedComments;
         // Clear positioned comments from the value to avoid duplication since SelectItem handles them
         arg.value.positionedComments = null;
-        // Add 'before' positioned comments
+        // Add positioned comments in recorded order
         const beforeComments = arg.getPositionedComments('before');
+        const afterComments = arg.getPositionedComments('after');
+        const isParenExpression = arg.value instanceof ParenExpression;
         if (beforeComments.length > 0) {
             const commentTokens = this.createInlineCommentSequence(beforeComments);
             token.innerTokens.push(...commentTokens);
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         }
-        // Add the value (column name)
         token.innerTokens.push(this.visit(arg.value));
-        // Add 'after' positioned comments for the value
-        // Skip after comments if the value is ParenExpression (already handled in ParenExpression processing)
-        const afterComments = arg.getPositionedComments('after');
-        const isParenExpression = arg.value.constructor.name === 'ParenExpression';
         if (afterComments.length > 0 && !isParenExpression) {
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             const commentTokens = this.createInlineCommentSequence(afterComments);
@@ -1560,16 +1678,32 @@ export class SqlPrintTokenParser {
         }
     }
     visitFromClause(arg) {
-        const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'from', SqlPrintTokenContainerType.FromClause);
-        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-        token.innerTokens.push(this.visit(arg.source));
-        if (arg.joins) {
-            for (let i = 0; i < arg.joins.length; i++) {
-                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-                token.innerTokens.push(this.visit(arg.joins[i]));
+        // Build a declaration order map so JOIN ON operands can be normalized later.
+        let contextPushed = false;
+        if (this.normalizeJoinConditionOrder) {
+            const aliasOrder = this.buildJoinAliasOrder(arg);
+            if (aliasOrder.size > 0) {
+                this.joinConditionContexts.push({ aliasOrder });
+                contextPushed = true;
+            }
+        }
+        try {
+            const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'from', SqlPrintTokenContainerType.FromClause);
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(this.visit(arg.source));
+            if (arg.joins) {
+                for (let i = 0; i < arg.joins.length; i++) {
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                    token.innerTokens.push(this.visit(arg.joins[i]));
+                }
+            }
+            return token;
+        }
+        finally {
+            if (contextPushed) {
+                this.joinConditionContexts.pop();
             }
         }
-        return token;
     }
     visitJoinClause(arg) {
         // Print join clause: [joinType] [lateral] [source] [on/using ...]
@@ -1619,12 +1753,123 @@ export class SqlPrintTokenParser {
         return token;
     }
     visitJoinOnClause(arg) {
+        // Normalize JOIN ON predicate columns to follow declaration order when enabled.
+        if (this.normalizeJoinConditionOrder) {
+            const aliasOrder = this.getCurrentJoinAliasOrder();
+            if (aliasOrder) {
+                this.normalizeJoinConditionValue(arg.condition, aliasOrder);
+            }
+        }
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.JoinOnClause);
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'on'));
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(this.visit(arg.condition));
         return token;
     }
+    getCurrentJoinAliasOrder() {
+        if (this.joinConditionContexts.length === 0) {
+            return null;
+        }
+        return this.joinConditionContexts[this.joinConditionContexts.length - 1].aliasOrder;
+    }
+    buildJoinAliasOrder(fromClause) {
+        const aliasOrder = new Map();
+        let nextIndex = 0;
+        const registerSource = (source) => {
+            const identifiers = this.collectSourceIdentifiers(source);
+            if (identifiers.length === 0) {
+                return;
+            }
+            // Track the earliest declaration index for each identifier found in the FROM clause.
+            for (const identifier of identifiers) {
+                const key = identifier.toLowerCase();
+                if (!aliasOrder.has(key)) {
+                    aliasOrder.set(key, nextIndex);
+                }
+            }
+            nextIndex++;
+        };
+        registerSource(fromClause.source);
+        if (fromClause.joins) {
+            for (const joinClause of fromClause.joins) {
+                registerSource(joinClause.source);
+            }
+        }
+        return aliasOrder;
+    }
+    collectSourceIdentifiers(source) {
+        const identifiers = [];
+        const aliasName = source.getAliasName();
+        if (aliasName) {
+            identifiers.push(aliasName);
+        }
+        // Capture table identifiers so unaliased tables can still be matched.
+        if (source.datasource instanceof TableSource) {
+            const tableComponent = source.datasource.table.name;
+            identifiers.push(tableComponent);
+            const fullName = source.datasource.getSourceName();
+            if (fullName && fullName !== tableComponent) {
+                identifiers.push(fullName);
+            }
+        }
+        return identifiers;
+    }
+    normalizeJoinConditionValue(condition, aliasOrder) {
+        // Walk the value tree so every comparison within the JOIN predicate is inspected.
+        const kind = condition.getKind();
+        if (kind === ParenExpression.kind) {
+            const paren = condition;
+            this.normalizeJoinConditionValue(paren.expression, aliasOrder);
+            return;
+        }
+        if (kind === BinaryExpression.kind) {
+            const binary = condition;
+            this.normalizeJoinConditionValue(binary.left, aliasOrder);
+            this.normalizeJoinConditionValue(binary.right, aliasOrder);
+            this.normalizeBinaryEquality(binary, aliasOrder);
+        }
+    }
+    normalizeBinaryEquality(binary, aliasOrder) {
+        // Only normalize simple equality comparisons, leaving other operators untouched.
+        const operatorValue = binary.operator.value.toLowerCase();
+        if (operatorValue !== '=') {
+            return;
+        }
+        const leftOwner = this.resolveColumnOwner(binary.left);
+        const rightOwner = this.resolveColumnOwner(binary.right);
+        if (!leftOwner || !rightOwner || leftOwner === rightOwner) {
+            return;
+        }
+        const leftOrder = aliasOrder.get(leftOwner);
+        const rightOrder = aliasOrder.get(rightOwner);
+        if (leftOrder === undefined || rightOrder === undefined) {
+            return;
+        }
+        if (leftOrder > rightOrder) {
+            // Swap operands so the earlier declared table appears on the left.
+            const originalLeft = binary.left;
+            binary.left = binary.right;
+            binary.right = originalLeft;
+        }
+    }
+    resolveColumnOwner(value) {
+        var _a;
+        const kind = value.getKind();
+        if (kind === ColumnReference.kind) {
+            // Column references expose their qualifier namespace, which we normalize for lookups.
+            const columnRef = value;
+            const namespace = columnRef.getNamespace();
+            if (!namespace) {
+                return null;
+            }
+            const qualifier = namespace.includes('.') ? (_a = namespace.split('.').pop()) !== null && _a !== void 0 ? _a : '' : namespace;
+            return qualifier.toLowerCase();
+        }
+        if (kind === ParenExpression.kind) {
+            return this.resolveColumnOwner(value.expression);
+        }
+        return null;
+    }
     visitJoinUsingClause(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.JoinUsingClause);
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'using'));
@@ -1803,14 +2048,12 @@ export class SqlPrintTokenParser {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.SimpleSelectQuery);
         // Handle positioned comments for SimpleSelectQuery (unified spec)
         if (arg.headerComments && arg.headerComments.length > 0) {
-            // Fallback to legacy headerComments if no positioned comments
-            // For smart comment style, treat headerComments as a single multi-line block
-            if (this.commentStyle === 'smart' && arg.headerComments.length > 1) {
+            if (this.shouldMergeHeaderComments(arg.headerComments)) {
                 const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
                 token.innerTokens.push(mergedHeaderComment);
             }
             else {
-                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
+                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments, true);
                 token.innerTokens.push(...headerCommentBlocks);
             }
             if (arg.withClause) {
@@ -1891,11 +2134,18 @@ export class SqlPrintTokenParser {
         const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'values', SqlPrintTokenContainerType.ValuesQuery);
         // Add headerComments before VALUES keyword
         if (arg.headerComments && arg.headerComments.length > 0) {
-            const headerCommentBlocks = this.createCommentBlocks(arg.headerComments);
-            for (const commentBlock of headerCommentBlocks) {
-                token.innerTokens.push(commentBlock);
+            if (this.shouldMergeHeaderComments(arg.headerComments)) {
+                const mergedHeaderComment = this.createHeaderMultiLineCommentBlock(arg.headerComments);
+                token.innerTokens.push(mergedHeaderComment);
                 token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             }
+            else {
+                const headerCommentBlocks = this.createCommentBlocks(arg.headerComments, true);
+                for (const commentBlock of headerCommentBlocks) {
+                    token.innerTokens.push(commentBlock);
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                }
+            }
         }
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         const values = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.Values);
@@ -1931,22 +2181,27 @@ export class SqlPrintTokenParser {
     }
     visitInsertQuery(arg) {
         const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.InsertQuery);
-        // Process the insert clause
+        if (arg.withClause) {
+            token.innerTokens.push(arg.withClause.accept(this));
+        }
         token.innerTokens.push(this.visit(arg.insertClause));
         // Process the select query if present
         if (arg.selectQuery) {
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             token.innerTokens.push(this.visit(arg.selectQuery));
         }
+        if (arg.returningClause) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.returningClause.accept(this));
+        }
         return token;
     }
     visitInsertClause(arg) {
-        const token = new SqlPrintToken(SqlPrintTokenType.container, '');
-        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.InsertClause);
         token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'insert into'));
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         token.innerTokens.push(arg.source.accept(this));
-        if (arg.columns.length > 0) {
+        if (arg.columns && arg.columns.length > 0) {
             token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
             for (let i = 0; i < arg.columns.length; i++) {
                 if (i > 0) {
@@ -1958,14 +2213,184 @@ export class SqlPrintTokenParser {
         }
         return token;
     }
-    visitUpdateQuery(arg) {
-        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.UpdateQuery);
+    visitDeleteQuery(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.DeleteQuery);
+        // Attach WITH clause tokens when present before the DELETE command.
         if (arg.withClause) {
             token.innerTokens.push(arg.withClause.accept(this));
         }
-        token.innerTokens.push(arg.updateClause.accept(this));
-        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-        token.innerTokens.push(arg.setClause.accept(this));
+        token.innerTokens.push(arg.deleteClause.accept(this));
+        // Append USING clause when the DELETE references additional sources.
+        if (arg.usingClause) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.usingClause.accept(this));
+        }
+        // Append WHERE clause to restrict affected rows.
+        if (arg.whereClause) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.whereClause.accept(this));
+        }
+        // Append RETURNING clause when the DELETE yields output columns.
+        if (arg.returningClause) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.returningClause.accept(this));
+        }
+        return token;
+    }
+    visitDeleteClause(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'delete from', SqlPrintTokenContainerType.DeleteClause);
+        // Render the target relation immediately after the DELETE FROM keyword.
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.source.accept(this));
+        return token;
+    }
+    visitUsingClause(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'using', SqlPrintTokenContainerType.UsingClause);
+        if (arg.sources.length > 0) {
+            // Attach the first USING source directly after the keyword.
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            for (let i = 0; i < arg.sources.length; i++) {
+                if (i > 0) {
+                    // Separate subsequent sources with comma and space for clarity.
+                    token.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+                }
+                token.innerTokens.push(this.visit(arg.sources[i]));
+            }
+        }
+        return token;
+    }
+    visitMergeQuery(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.MergeQuery);
+        if (arg.withClause) {
+            token.innerTokens.push(arg.withClause.accept(this));
+        }
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'merge into'));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.target.accept(this));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'using'));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.source.accept(this));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        const onClauseToken = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.JoinOnClause);
+        onClauseToken.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'on'));
+        onClauseToken.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        onClauseToken.innerTokens.push(arg.onCondition.accept(this));
+        token.innerTokens.push(onClauseToken);
+        for (const clause of arg.whenClauses) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(clause.accept(this));
+        }
+        return token;
+    }
+    visitMergeWhenClause(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.MergeWhenClause);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, this.mergeMatchTypeToKeyword(arg.matchType)));
+        if (arg.condition) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'and'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.condition.accept(this));
+        }
+        const thenLeadingComments = arg.getThenLeadingComments();
+        const thenKeywordToken = new SqlPrintToken(SqlPrintTokenType.keyword, 'then');
+        if (thenLeadingComments.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            const commentBlocks = this.createCommentBlocks(thenLeadingComments);
+            token.innerTokens.push(...commentBlocks);
+            token.innerTokens.push(thenKeywordToken);
+        }
+        else {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(thenKeywordToken);
+        }
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.action.accept(this));
+        return token;
+    }
+    visitMergeUpdateAction(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.MergeUpdateAction);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'update'));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.setClause.accept(this));
+        if (arg.whereClause) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.whereClause.accept(this));
+        }
+        return token;
+    }
+    visitMergeDeleteAction(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.MergeDeleteAction);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'delete'));
+        if (arg.whereClause) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.whereClause.accept(this));
+        }
+        return token;
+    }
+    visitMergeInsertAction(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.MergeInsertAction);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'insert'));
+        if (arg.columns && arg.columns.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
+            for (let i = 0; i < arg.columns.length; i++) {
+                if (i > 0) {
+                    token.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+                }
+                token.innerTokens.push(arg.columns[i].accept(this));
+            }
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        }
+        if (arg.defaultValues) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'default values'));
+            return token;
+        }
+        if (arg.values) {
+            const leadingValuesComments = arg.getValuesLeadingComments();
+            if (leadingValuesComments.length > 0) {
+                token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.commentNewline, ''));
+                const commentBlocks = this.createCommentBlocks(leadingValuesComments);
+                token.innerTokens.push(...commentBlocks);
+            }
+            else {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            const valuesKeywordToken = new SqlPrintToken(SqlPrintTokenType.keyword, 'values');
+            token.innerTokens.push(valuesKeywordToken);
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
+            token.innerTokens.push(arg.values.accept(this));
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        }
+        return token;
+    }
+    visitMergeDoNothingAction(_) {
+        return new SqlPrintToken(SqlPrintTokenType.keyword, 'do nothing', SqlPrintTokenContainerType.MergeDoNothingAction);
+    }
+    mergeMatchTypeToKeyword(matchType) {
+        switch (matchType) {
+            case 'matched':
+                return 'when matched';
+            case 'not_matched':
+                return 'when not matched';
+            case 'not_matched_by_source':
+                return 'when not matched by source';
+            case 'not_matched_by_target':
+                return 'when not matched by target';
+            default:
+                return 'when';
+        }
+    }
+    visitUpdateQuery(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.UpdateQuery);
+        if (arg.withClause) {
+            token.innerTokens.push(arg.withClause.accept(this));
+        }
+        token.innerTokens.push(arg.updateClause.accept(this));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.setClause.accept(this));
         if (arg.fromClause) {
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             token.innerTokens.push(arg.fromClause.accept(this));
@@ -1987,7 +2412,7 @@ export class SqlPrintTokenParser {
         return token;
     }
     visitSetClause(arg) {
-        const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'set', SqlPrintTokenContainerType.SelectClause);
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, 'set', SqlPrintTokenContainerType.SetClause);
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
         for (let i = 0; i < arg.items.length; i++) {
             if (i > 0) {
@@ -2018,15 +2443,481 @@ export class SqlPrintTokenParser {
         return token;
     }
     visitCreateTableQuery(arg) {
-        const token = new SqlPrintToken(SqlPrintTokenType.keyword, arg.isTemporary ? 'create temporary table' : 'create table', SqlPrintTokenContainerType.CreateTableQuery);
+        var _a;
+        const baseKeyword = arg.isTemporary ? 'create temporary table' : 'create table';
+        let keywordText = arg.ifNotExists ? `${baseKeyword} if not exists` : baseKeyword;
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, keywordText, SqlPrintTokenContainerType.CreateTableQuery);
         token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
-        token.innerTokens.push(arg.tableName.accept(this));
+        const qualifiedName = new QualifiedName((_a = arg.namespaces) !== null && _a !== void 0 ? _a : null, arg.tableName);
+        token.innerTokens.push(qualifiedName.accept(this));
+        const definitionEntries = [...arg.columns, ...arg.tableConstraints];
+        if (definitionEntries.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
+            const definitionToken = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.CreateTableDefinition);
+            for (let i = 0; i < definitionEntries.length; i++) {
+                if (i > 0) {
+                    definitionToken.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+                }
+                definitionToken.innerTokens.push(definitionEntries[i].accept(this));
+            }
+            token.innerTokens.push(definitionToken);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        }
+        if (arg.tableOptions) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.tableOptions.accept(this));
+        }
         if (arg.asSelectQuery) {
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'as'));
             token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
             token.innerTokens.push(arg.asSelectQuery.accept(this));
         }
+        if (arg.withDataOption) {
+            // Reconstruct WITH [NO] DATA clause to mirror PostgreSQL CREATE TABLE semantics.
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'with'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            if (arg.withDataOption === 'with-no-data') {
+                token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'no'));
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'data'));
+        }
+        return token;
+    }
+    visitTableColumnDefinition(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.TableColumnDefinition);
+        token.innerTokens.push(arg.name.accept(this));
+        if (arg.dataType) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.dataType.accept(this));
+        }
+        for (const constraint of arg.constraints) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(constraint.accept(this));
+        }
+        return token;
+    }
+    visitColumnConstraintDefinition(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ColumnConstraintDefinition);
+        if (arg.constraintName) {
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'constraint'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.constraintName.accept(this));
+        }
+        const appendKeyword = (text) => {
+            if (token.innerTokens.length > 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, text));
+        };
+        const appendComponent = (component) => {
+            if (token.innerTokens.length > 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            token.innerTokens.push(component.accept(this));
+        };
+        switch (arg.kind) {
+            case 'not-null':
+                appendKeyword('not null');
+                break;
+            case 'null':
+                appendKeyword('null');
+                break;
+            case 'default':
+                appendKeyword('default');
+                if (arg.defaultValue) {
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                    token.innerTokens.push(arg.defaultValue.accept(this));
+                }
+                break;
+            case 'primary-key':
+                appendKeyword('primary key');
+                break;
+            case 'unique':
+                appendKeyword('unique');
+                break;
+            case 'references':
+                if (arg.reference) {
+                    appendComponent(arg.reference);
+                }
+                break;
+            case 'check':
+                if (arg.checkExpression) {
+                    appendKeyword('check');
+                    token.innerTokens.push(this.wrapWithParenExpression(arg.checkExpression));
+                }
+                break;
+            case 'generated-always-identity':
+            case 'generated-by-default-identity':
+            case 'raw':
+                if (arg.rawClause) {
+                    appendComponent(arg.rawClause);
+                }
+                break;
+        }
+        return token;
+    }
+    visitTableConstraintDefinition(arg) {
+        var _a, _b, _c;
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.TableConstraintDefinition);
+        const appendKeyword = (text) => {
+            if (token.innerTokens.length > 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, text));
+        };
+        const appendComponent = (component) => {
+            if (token.innerTokens.length > 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            token.innerTokens.push(component.accept(this));
+        };
+        const appendColumns = (columns) => {
+            if (!columns || columns.length === 0) {
+                return;
+            }
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
+            const listToken = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ValueList);
+            for (let i = 0; i < columns.length; i++) {
+                if (i > 0) {
+                    listToken.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+                }
+                listToken.innerTokens.push(columns[i].accept(this));
+            }
+            token.innerTokens.push(listToken);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        };
+        const useMysqlConstraintStyle = this.constraintStyle === 'mysql';
+        const inlineNameKinds = new Set(['primary-key', 'unique', 'foreign-key']);
+        const shouldInlineConstraintName = useMysqlConstraintStyle && !!arg.constraintName && inlineNameKinds.has(arg.kind);
+        if (arg.constraintName && !shouldInlineConstraintName) {
+            appendKeyword('constraint');
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.constraintName.accept(this));
+        }
+        switch (arg.kind) {
+            case 'primary-key':
+                appendKeyword('primary key');
+                if (shouldInlineConstraintName && arg.constraintName) {
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                    token.innerTokens.push(arg.constraintName.accept(this));
+                }
+                appendColumns((_a = arg.columns) !== null && _a !== void 0 ? _a : []);
+                break;
+            case 'unique':
+                if (useMysqlConstraintStyle) {
+                    appendKeyword('unique key');
+                    if (shouldInlineConstraintName && arg.constraintName) {
+                        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                        token.innerTokens.push(arg.constraintName.accept(this));
+                    }
+                }
+                else {
+                    appendKeyword('unique');
+                }
+                appendColumns((_b = arg.columns) !== null && _b !== void 0 ? _b : []);
+                break;
+            case 'foreign-key':
+                appendKeyword('foreign key');
+                if (shouldInlineConstraintName && arg.constraintName) {
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                    token.innerTokens.push(arg.constraintName.accept(this));
+                }
+                appendColumns((_c = arg.columns) !== null && _c !== void 0 ? _c : []);
+                if (arg.reference) {
+                    token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+                    token.innerTokens.push(arg.reference.accept(this));
+                }
+                break;
+            case 'check':
+                if (arg.checkExpression) {
+                    appendKeyword('check');
+                    token.innerTokens.push(this.wrapWithParenExpression(arg.checkExpression));
+                }
+                break;
+            case 'raw':
+                if (arg.rawClause) {
+                    appendComponent(arg.rawClause);
+                }
+                break;
+        }
+        return token;
+    }
+    wrapWithParenExpression(expression) {
+        // Reuse existing parentheses groups to avoid double-wrapping when callers already provided them.
+        if (expression instanceof ParenExpression) {
+            return this.visit(expression);
+        }
+        // Synthesize a ParenExpression wrapper so nested boolean groups render with consistent indentation.
+        const synthetic = new ParenExpression(expression);
+        return this.visit(synthetic);
+    }
+    visitReferenceDefinition(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ReferenceDefinition);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'references'));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.targetTable.accept(this));
+        if (arg.columns && arg.columns.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
+            const columnList = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ValueList);
+            for (let i = 0; i < arg.columns.length; i++) {
+                if (i > 0) {
+                    columnList.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+                }
+                columnList.innerTokens.push(arg.columns[i].accept(this));
+            }
+            token.innerTokens.push(columnList);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        }
+        if (arg.matchType) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, `match ${arg.matchType}`));
+        }
+        if (arg.onDelete) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'on delete'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.onDelete));
+        }
+        if (arg.onUpdate) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'on update'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.onUpdate));
+        }
+        if (arg.deferrable === 'deferrable') {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'deferrable'));
+        }
+        else if (arg.deferrable === 'not deferrable') {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'not deferrable'));
+        }
+        if (arg.initially === 'immediate') {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'initially immediate'));
+        }
+        else if (arg.initially === 'deferred') {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'initially deferred'));
+        }
+        return token;
+    }
+    visitCreateIndexStatement(arg) {
+        const keywordParts = ['create'];
+        if (arg.unique) {
+            keywordParts.push('unique');
+        }
+        keywordParts.push('index');
+        if (arg.concurrently) {
+            keywordParts.push('concurrently');
+        }
+        if (arg.ifNotExists) {
+            keywordParts.push('if not exists');
+        }
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, keywordParts.join(' '), SqlPrintTokenContainerType.CreateIndexStatement);
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.indexName.accept(this));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'on'));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.tableName.accept(this));
+        if (arg.usingMethod) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'using'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.usingMethod.accept(this));
+        }
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
+        const columnList = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.IndexColumnList);
+        for (let i = 0; i < arg.columns.length; i++) {
+            if (i > 0) {
+                columnList.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+            }
+            columnList.innerTokens.push(arg.columns[i].accept(this));
+        }
+        token.innerTokens.push(columnList);
+        token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        if (arg.include && arg.include.length > 0) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'include'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_OPEN_TOKEN);
+            const includeList = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ValueList);
+            for (let i = 0; i < arg.include.length; i++) {
+                if (i > 0) {
+                    includeList.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+                }
+                includeList.innerTokens.push(arg.include[i].accept(this));
+            }
+            token.innerTokens.push(includeList);
+            token.innerTokens.push(SqlPrintTokenParser.PAREN_CLOSE_TOKEN);
+        }
+        if (arg.withOptions) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.withOptions.accept(this));
+        }
+        if (arg.tablespace) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'tablespace'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.tablespace.accept(this));
+        }
+        if (arg.where) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'where'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(this.visit(arg.where));
+        }
+        return token;
+    }
+    visitIndexColumnDefinition(arg) {
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.IndexColumnDefinition);
+        token.innerTokens.push(this.visit(arg.expression));
+        if (arg.collation) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'collate'));
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.collation.accept(this));
+        }
+        if (arg.operatorClass) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(arg.operatorClass.accept(this));
+        }
+        if (arg.sortOrder) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.sortOrder));
+        }
+        if (arg.nullsOrder) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, `nulls ${arg.nullsOrder}`));
+        }
+        return token;
+    }
+    visitDropTableStatement(arg) {
+        const keyword = arg.ifExists ? 'drop table if exists' : 'drop table';
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, keyword, SqlPrintTokenContainerType.DropTableStatement);
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        const tableList = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ValueList);
+        for (let i = 0; i < arg.tables.length; i++) {
+            if (i > 0) {
+                tableList.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+            }
+            tableList.innerTokens.push(arg.tables[i].accept(this));
+        }
+        token.innerTokens.push(tableList);
+        if (arg.behavior) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.behavior));
+        }
+        return token;
+    }
+    visitDropIndexStatement(arg) {
+        const keywordParts = ['drop', 'index'];
+        if (arg.concurrently) {
+            keywordParts.push('concurrently');
+        }
+        if (arg.ifExists) {
+            keywordParts.push('if exists');
+        }
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, keywordParts.join(' '), SqlPrintTokenContainerType.DropIndexStatement);
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        const indexList = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.ValueList);
+        for (let i = 0; i < arg.indexNames.length; i++) {
+            if (i > 0) {
+                indexList.innerTokens.push(...SqlPrintTokenParser.commaSpaceTokens());
+            }
+            indexList.innerTokens.push(arg.indexNames[i].accept(this));
+        }
+        token.innerTokens.push(indexList);
+        if (arg.behavior) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.behavior));
+        }
+        return token;
+    }
+    visitAlterTableStatement(arg) {
+        const keywordParts = ['alter', 'table'];
+        if (arg.ifExists) {
+            keywordParts.push('if exists');
+        }
+        if (arg.only) {
+            keywordParts.push('only');
+        }
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, keywordParts.join(' '), SqlPrintTokenContainerType.AlterTableStatement);
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.table.accept(this));
+        for (let i = 0; i < arg.actions.length; i++) {
+            if (i === 0) {
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            else {
+                token.innerTokens.push(SqlPrintTokenParser.COMMA_TOKEN);
+                token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            }
+            token.innerTokens.push(arg.actions[i].accept(this));
+        }
+        return token;
+    }
+    visitAlterTableAddConstraint(arg) {
+        const keyword = arg.ifNotExists ? 'add if not exists' : 'add';
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.AlterTableAddConstraint);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, keyword));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.constraint.accept(this));
+        if (arg.notValid) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, 'not valid'));
+        }
+        return token;
+    }
+    visitAlterTableDropConstraint(arg) {
+        let keyword = 'drop constraint';
+        if (arg.ifExists) {
+            keyword += ' if exists';
+        }
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.AlterTableDropConstraint);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, keyword));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.constraintName.accept(this));
+        if (arg.behavior) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.behavior));
+        }
+        return token;
+    }
+    visitAlterTableDropColumn(arg) {
+        let keyword = 'drop column';
+        if (arg.ifExists) {
+            keyword += ' if exists';
+        }
+        const token = new SqlPrintToken(SqlPrintTokenType.container, '', SqlPrintTokenContainerType.AlterTableDropColumn);
+        token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, keyword));
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.columnName.accept(this));
+        if (arg.behavior) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.behavior));
+        }
+        return token;
+    }
+    visitDropConstraintStatement(arg) {
+        let keyword = 'drop constraint';
+        if (arg.ifExists) {
+            keyword += ' if exists';
+        }
+        const token = new SqlPrintToken(SqlPrintTokenType.keyword, keyword, SqlPrintTokenContainerType.DropConstraintStatement);
+        token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+        token.innerTokens.push(arg.constraintName.accept(this));
+        if (arg.behavior) {
+            token.innerTokens.push(SqlPrintTokenParser.SPACE_TOKEN);
+            token.innerTokens.push(new SqlPrintToken(SqlPrintTokenType.keyword, arg.behavior));
+        }
         return token;
     }
 }