spark-sql-language-server 0.0.1-beta.6 → 0.2.0-beta.0

package/out-tsc/formatter/strategy-based-formatter.js

@@ -0,0 +1,3808 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyBasedFormatter = void 0;
+const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
+const tree_1 = require("antlr4ts/tree");
+const core_1 = require("./core");
+const strategies_1 = require("./strategies");
+const block_strategy_1 = require("./strategies/block.strategy");
+const SparkSQLLexer_1 = require("../lib/SparkSQLLexer");
+const SparkSQLParser_1 = require("../lib/SparkSQLParser");
+const typings_1 = require("../typings");
+/**
+ * Strategy-based SQL Formatter
+ *
+ * Uses a registry of strategies to format different SQL statement types.
+ */
+class StrategyBasedFormatter extends tree_1.AbstractParseTreeVisitor {
+    constructor(tokens, config) {
+        super();
+        this.tokens = tokens;
+        this.config = config;
+        this.textEdits = [];
+        this.formattingErrors = [];
+        this.editCollector = new core_1.EditCollector();
+        this.blockStrategy = new block_strategy_1.BlockStrategy();
+        // Legacy flags for compatibility during transition
+        this.inPipeOperatorRightSide = false;
+        this.inPipeSubquery = false;
+        this.inWindowClause = false;
+        this.inUnpivotLongContent = false;
+        this.newline = '\n';
+        this.context = new core_1.FormattingContext(config.tabSize);
+        this.maxParenthesisLength = config.maxParenthesisLength ?? typings_1.DEFAULT_MAX_PARENTHESIS_LENGTH;
+        this.strategies = [...strategies_1.allStrategies];
+        // Create bridge with visitor reference
+        this.bridge = new core_1.StrategyFormattingBridge({
+            tokens: this.tokens,
+            context: this.context,
+            collector: this.editCollector,
+            visitor: {
+                visit: ctx => this.visit(ctx),
+                visitChildren: ctx => this.visitChildren(ctx)
+            }
+        });
+    }
+    /**
+     * Get formatted text edits
+     */
+    getTextEdits() {
+        return this.textEdits;
+    }
+    /**
+     * Process the parse tree and collect edits
+     */
+    format(ctx) {
+        this.textEdits = [];
+        this.formattingErrors = [];
+        this.editCollector.clear();
+        // Visit the tree
+        this.visit(ctx);
+        // Post-processing: normalize keyword spacing
+        this.normalizeAllKeywordSpacing();
+        // Post-processing: compress consecutive spaces
+        this.compressConsecutiveSpaces();
+        // Post-processing: clean parentheses spaces and comma spaces
+        this.cleanParenthesesSpaces();
+        // Collect all edits
+        this.textEdits = this.editCollector.getEdits();
+        return this.textEdits;
+    }
+    defaultResult() {
+        return;
+    }
+    // ==================== Strategy Dispatch ====================
+    /**
+     * Try to format using registered strategies, fallback to default behavior
+     */
+    tryFormatWithStrategy(ctx) {
+        for (const strategy of this.strategies) {
+            if (strategy.canHandle(ctx)) {
+                try {
+                    strategy.format(ctx, this.bridge);
+                    return true;
+                }
+                catch (error) {
+                    // Log error but continue
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    this.formattingErrors.push({
+                        message: `Strategy ${strategy.id} failed: ${errorMessage}`,
+                        line: ctx.start.line - 1
+                    });
+                }
+            }
+        }
+        return false;
+    }
+    // ==================== Program & Statements ====================
+    visitProgram(ctx) {
+        const statements = ctx.statements();
+        if (statements) {
+            this.visit(statements);
+        }
+        this.compressConsecutiveSpaces();
+    }
+    visitStatements(ctx) {
+        const stmtForFoldings = ctx.statementForFolding();
+        stmtForFoldings.forEach((sff, index) => {
+            if (index > 0) {
+                // Handle statement separation
+                const prevStmt = stmtForFoldings[index - 1];
+                const prevStmtEnd = prevStmt._stop?.stopIndex ?? 0;
+                const currStmtStart = sff._start?.startIndex ?? 0;
+                const commentsBetween = this.findCommentTokensBetween(prevStmtEnd + 1, currStmtStart);
+                if (commentsBetween.length > 0) {
+                    const firstComment = commentsBetween[0];
+                    const prevToken = this.getPreviousNonHiddenTokenByStartIndex(firstComment.startIndex);
+                    if (prevToken) {
+                        const prevEndPos = this.getTokenEndPosition(prevToken);
+                        this.addTextEdit({
+                            range: {
+                                start: prevEndPos,
+                                end: { line: firstComment.line - 1, character: firstComment.charPositionInLine }
+                            },
+                            newText: this.newline
+                        });
+                    }
+                }
+                else {
+                    const prevStmt = stmtForFoldings[index - 1];
+                    if (prevStmt._stop) {
+                        const prevStmtEndIndex = prevStmt._stop.stopIndex;
+                        const currStmtStartIndex = sff._start?.startIndex ?? 0;
+                        const allTokens = this.tokens.getTokens();
+                        let semicolonToken;
+                        for (const token of allTokens) {
+                            if (token.startIndex > prevStmtEndIndex && token.startIndex < currStmtStartIndex) {
+                                if (token.channel === 0 && token.text === ';') {
+                                    semicolonToken = token;
+                                    break;
+                                }
+                            }
+                        }
+                        if (semicolonToken) {
+                            const semicolonEndPos = this.getTokenEndPosition(semicolonToken);
+                            const currStmtRange = { start: { line: sff.start.line - 1, character: sff.start.charPositionInLine } };
+                            this.addTextEdit({
+                                range: { start: semicolonEndPos, end: currStmtRange.start },
+                                newText: this.newline.repeat(2)
+                            });
+                        }
+                    }
+                }
+            }
+            try {
+                this.visit(sff);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.formattingErrors.push({
+                    message: `Statement formatting failed: ${errorMessage}`,
+                    line: sff.start.line - 1
+                });
+            }
+        });
+        ctx.statementEnd().forEach(stmtEnd => this.visit(stmtEnd));
+    }
+    visitStatementEnd(ctx) {
+        const semicolon = ctx.SEMICOLON();
+        if (semicolon) {
+            // Clean whitespace before semicolon
+            const prevToken = this.getPreviousNonHiddenTokenByStartIndex(semicolon.symbol.startIndex);
+            if (prevToken) {
+                const prevEndPos = this.getTokenEndPosition(prevToken);
+                this.addTextEdit({
+                    range: {
+                        start: prevEndPos,
+                        end: { line: semicolon.symbol.line - 1, character: semicolon.symbol.charPositionInLine }
+                    },
+                    newText: ''
+                });
+            }
+            // Clean whitespace after semicolon (before comment on same line)
+            const allTokens = this.tokens.getTokens();
+            const semicolonIdx = allTokens.indexOf(semicolon.symbol);
+            const semicolonEndPos = this.getTokenEndPosition(semicolon.symbol);
+            for (let i = semicolonIdx + 1; i < allTokens.length; i++) {
+                const token = allTokens[i];
+                // Skip EOF
+                if (token.type === 0)
+                    break;
+                // Skip only whitespace tokens - comments (channel 1) should be preserved
+                if (token.channel === 1 && token.text?.trim() === '')
+                    continue;
+                // Found next meaningful token on same line (comment or other)
+                if (token.line === semicolon.symbol.line) {
+                    const nextTokenStartPos = {
+                        line: token.line - 1,
+                        character: token.charPositionInLine
+                    };
+                    // Only add edit if there's actual whitespace to clean
+                    if (semicolonEndPos.character < nextTokenStartPos.character) {
+                        this.addTextEdit({
+                            range: {
+                                start: semicolonEndPos,
+                                end: nextTokenStartPos
+                            },
+                            newText: ' '
+                        });
+                    }
+                    break;
+                }
+                // Token on different line - stop looking
+                break;
+            }
+        }
+    }
+    visitStatementForFolding(ctx) {
+        // Delegate to the inner statement, setResetStatement, or compoundStatement
+        const stmt = ctx.statement();
+        const setResetStmt = ctx.setResetStatement();
+        const compoundStmt = ctx.compoundStatement();
+        if (stmt) {
+            this.visit(stmt);
+        }
+        else if (setResetStmt) {
+            this.visit(setResetStmt);
+        }
+        else if (compoundStmt) {
+            this.visit(compoundStmt);
+        }
+    }
+    // ==================== DDL Statements ====================
+    visitCreateTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreateTableLike(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreateTableHeader(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreateTableClauses(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitTableProvider(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitTableElementList(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitColDefinition(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitReplaceTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitReplaceTableHeader(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreatePipelineDataset(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreatePipelineDatasetHeader(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreatePipelineInsertIntoFlow(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreatePipelineFlowHeader(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitPartitionFieldList(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitPropertyList(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitExpressionPropertyList(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitPropertyWithKeyAndEquals(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitExpressionPropertyWithKeyAndEquals(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreateView(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreateMetricView(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreateTempViewUsing(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCreateFunction(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitResource(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== ALTER TABLE ====================
+    visitAddTableColumns(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRenameTableColumn(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDropTableColumns(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRenameTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitSetTableProperties(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitUnsetTableProperties(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitAlterTableAlterColumn(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitAlterColumnAction(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitHiveChangeColumn(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitAlterViewQuery(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitSetTableLocation(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== PARTITION Statements ====================
+    visitAddTablePartition(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDropTablePartitions(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRenameTablePartition(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== DROP Statements ====================
+    visitDropTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDropView(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDropFunction(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDropNamespace(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== RESOURCE Management Statements ====================
+    visitManageResource(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== SET/RESET Statements ====================
+    visitSetVariable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== INDEX Statements ====================
+    visitCreateIndex(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDropIndex(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== DML Statements ====================
+    visitQuery(ctx) {
+        if (ctx.ctes()) {
+            this.updateBeforeNextTokenByContext(ctx.ctes(), this.newlineIndent);
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== CTE (Common Table Expression) ====================
+    visitCtes(ctx) {
+        // Ensure single space after WITH keyword
+        const withNode = ctx.WITH();
+        if (withNode) {
+            this.updateBeforeNextTokenByNode(withNode, ' ');
+        }
+        // Handle RECURSIVE keyword if present
+        const recursiveNode = ctx.RECURSIVE();
+        if (recursiveNode) {
+            this.updateAfterPreviousTokenByNode(recursiveNode, ' ');
+            this.updateBeforeNextTokenByNode(recursiveNode, ' ');
+        }
+        // Format commas between CTEs - each namedQuery on new line after comma
+        const namedQueries = ctx.namedQuery();
+        for (let i = 1; i < namedQueries.length; i++) {
+            this.updateAfterPreviousTokenByContext(namedQueries[i], this.newlineIndent);
+        }
+        super.visitChildren(ctx);
+    }
+    visitNamedQuery(ctx) {
+        // Format AS keyword
+        this.normalizeKeywordSpacing(ctx.AS());
+        // Format the parentheses and query content
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen && rightParen) {
+            // Content on new line with indent after left parenthesis
+            this.addIndent();
+            this.updateBeforeNextTokenByNode(leftParen, this.newlineIndent);
+            // Visit children with added indent
+            super.visitChildren(ctx);
+            // Check if this CTE is part of a DML statement with INSERT
+            let parent = ctx.parent;
+            let isInDmlStatement = false;
+            while (parent) {
+                if (parent.constructor.name === 'DmlStatementContext') {
+                    isInDmlStatement = true;
+                    break;
+                }
+                parent = parent.parent;
+            }
+            // Reduce indent before right parenthesis (so it aligns with WITH)
+            this.minusIndent();
+            // Right parenthesis on new line without extra indent (aligned with WITH)
+            this.updateAfterPreviousTokenByNode(rightParen, this.newlineIndent);
+            if (isInDmlStatement) {
+                // For CTE followed by INSERT - keep INSERT on same line
+                this.updateBeforeNextTokenByNode(rightParen, ' ');
+            }
+        }
+        else {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRegularQuerySpecification(ctx) {
+        // Legacy visitor doesn't add indent here - each clause handles its own indentation
+        super.visitChildren(ctx);
+    }
+    visitSelectClause(ctx) {
+        // Ensure setQuantifier (DISTINCT/ALL) stays on same line as SELECT
+        const setQuantifier = ctx.setQuantifier();
+        if (setQuantifier) {
+            const selectToken = ctx.SELECT();
+            if (selectToken) {
+                this.updateBeforeNextTokenByNode(selectToken, ' ');
+            }
+        }
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitFromClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            const fromToken = ctx.FROM();
+            const relations = ctx.relation();
+            const lateralViews = ctx.lateralView();
+            // Add newline before FROM
+            if (fromToken) {
+                this.updateAfterPreviousTokenByNode(fromToken, this.newlineIndent);
+            }
+            // Add indent for FROM body (but not for VALUES - that handles its own indent)
+            let addedIndent = false;
+            if (relations.length > 0) {
+                // Check if first relation is an InlineTable (VALUES clause)
+                const firstRelationPrimary = relations[0].relationPrimary();
+                const isFromValues = firstRelationPrimary?.constructor.name === 'InlineTableDefault2Context';
+                if (!isFromValues) {
+                    this.addIndent();
+                    addedIndent = true;
+                    // First relation on new line with indent
+                    this.updateAfterPreviousTokenByContext(relations[0], this.newlineIndent);
+                }
+                // For FROM VALUES, visitInlineTable handles all formatting including indent
+            }
+            // Format commas in FROM clause
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+            }
+            // Visit relations
+            for (const relation of relations) {
+                this.visit(relation);
+            }
+            // Visit LATERAL VIEW with proper indent (one level more than FROM body)
+            if (lateralViews.length > 0 && addedIndent) {
+                // LATERAL VIEW should have one more level of indent
+                // But we already have FROM body indent, so LATERAL VIEW just needs newline
+                for (const lateralView of lateralViews) {
+                    this.visit(lateralView);
+                }
+            }
+            else {
+                for (const lateralView of lateralViews) {
+                    this.visit(lateralView);
+                }
+            }
+            // Visit PIVOT and UNPIVOT
+            const pivotClause = ctx.pivotClause();
+            if (pivotClause) {
+                this.visit(pivotClause);
+            }
+            const unpivotClause = ctx.unpivotClause();
+            if (unpivotClause) {
+                this.visit(unpivotClause);
+            }
+            if (addedIndent) {
+                this.minusIndent();
+            }
+        }
+    }
+    visitWhereClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            const whereToken = ctx.WHERE();
+            const booleanExpr = ctx.booleanExpression();
+            // Add newline before WHERE (except in pipe context where `|> WHERE` is on same line)
+            if (whereToken && !this.inPipeOperatorRightSide) {
+                this.updateAfterPreviousTokenByNode(whereToken, this.newlineIndent);
+            }
+            // Add indent for WHERE body and newline before expression
+            // In pipe context, this is handled by PipeWhereStrategy
+            if (booleanExpr && !this.inPipeOperatorRightSide) {
+                this.addIndent();
+                this.updateAfterPreviousTokenByContext(booleanExpr, this.newlineIndent);
+            }
+            super.visitChildren(ctx);
+            if (booleanExpr && !this.inPipeOperatorRightSide) {
+                this.minusIndent();
+            }
+        }
+    }
+    visitAggregationClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            const groupToken = ctx.GROUP();
+            const byToken = ctx.BY();
+            const expressions = ctx.namedExpression();
+            const groupByClauses = ctx.groupByClause();
+            // In pipe context, GROUP BY formatting is handled by PipeAggregateStrategy
+            if (!this.inPipeOperatorRightSide) {
+                // Add newline before GROUP BY
+                if (groupToken) {
+                    this.updateAfterPreviousTokenByNode(groupToken, this.newlineIndent);
+                }
+                if (byToken) {
+                    this.updateBeforeNextTokenByNode(byToken, ' ');
+                    this.updateAfterPreviousTokenByNode(byToken, ' ');
+                }
+            }
+            // Add indent for GROUP BY body (except in pipe context)
+            if (!this.inPipeOperatorRightSide) {
+                this.addIndent();
+            }
+            // Get first expression and put it on new line with indent
+            // In pipe context, use pipe-specific indent
+            const groupByBodyIndent = this.inPipeOperatorRightSide ? this.context.getPipeContentIndent() : this.newlineIndent;
+            if (groupByClauses.length > 0) {
+                this.updateAfterPreviousTokenByContext(groupByClauses[0], groupByBodyIndent);
+            }
+            else if (expressions.length > 0) {
+                this.updateAfterPreviousTokenByContext(expressions[0], groupByBodyIndent);
+            }
+            // Format commas
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, groupByBodyIndent);
+            }
+            // Handle WITH ROLLUP / WITH CUBE - on separate line
+            const withToken = ctx.WITH();
+            if (withToken) {
+                this.updateAfterPreviousTokenByNode(withToken, this.newlineIndent);
+                this.updateBeforeNextTokenByNode(withToken, ' ');
+            }
+            const rollupToken = ctx.ROLLUP();
+            if (rollupToken) {
+                this.updateAfterPreviousTokenByNode(rollupToken, ' ');
+            }
+            const cubeToken = ctx.CUBE();
+            if (cubeToken) {
+                this.updateAfterPreviousTokenByNode(cubeToken, ' ');
+            }
+            // Note: GROUPING SETS is handled in visitGroupingAnalytics
+            super.visitChildren(ctx);
+            if (!this.inPipeOperatorRightSide) {
+                this.minusIndent();
+            }
+        }
+    }
+    visitHavingClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            const havingToken = ctx.HAVING();
+            const booleanExpr = ctx.booleanExpression();
+            // Add newline before HAVING
+            if (havingToken) {
+                this.updateAfterPreviousTokenByNode(havingToken, this.newlineIndent);
+            }
+            // Add indent for HAVING body and newline before expression
+            if (booleanExpr) {
+                this.addIndent();
+                this.updateAfterPreviousTokenByContext(booleanExpr, this.newlineIndent);
+            }
+            super.visitChildren(ctx);
+            if (booleanExpr) {
+                this.minusIndent();
+            }
+        }
+    }
+    visitQueryOrganization(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            // In pipe context, ORDER BY / LIMIT should stay on same line as |>\n      // Pipe content indent: 5 spaces from `|>` position
+            const pipeContentIndent = this.inPipeOperatorRightSide ? this.context.getPipeContentIndent() : this.newlineIndent;
+            // For keywords like ORDER BY, use 3 spaces indent
+            const _pipeClauseIndent = this.inPipeOperatorRightSide ? `\n${this.indent}   ` : this.newlineIndent;
+            // Handle ORDER BY
+            if (ctx.ORDER()) {
+                // In pipe context: `|> ORDER BY` on same line, content indent 5 spaces
+                if (!this.inPipeOperatorRightSide) {
+                    this.updateAfterPreviousTokenByNode(ctx.ORDER(), this.newlineIndent);
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+                // Add indent and newline before first expression
+                if (!this.inPipeOperatorRightSide) {
+                    this.addIndent();
+                }
+                const expressions = ctx.sortItem();
+                if (expressions.length > 0) {
+                    this.updateAfterPreviousTokenByContext(expressions[0], pipeContentIndent);
+                }
+            }
+            // Handle CLUSTER BY
+            if (ctx.CLUSTER()) {
+                if (!this.inPipeOperatorRightSide) {
+                    this.updateAfterPreviousTokenByNode(ctx.CLUSTER(), this.newlineIndent);
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+                if (!this.inPipeOperatorRightSide) {
+                    this.addIndent();
+                }
+                const expressions = ctx.expression();
+                if (expressions.length > 0) {
+                    this.updateAfterPreviousTokenByContext(expressions[0], pipeContentIndent);
+                }
+            }
+            // Handle DISTRIBUTE BY
+            if (ctx.DISTRIBUTE()) {
+                if (!this.inPipeOperatorRightSide) {
+                    this.updateAfterPreviousTokenByNode(ctx.DISTRIBUTE(), this.newlineIndent);
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+                if (!this.inPipeOperatorRightSide) {
+                    this.addIndent();
+                }
+                const expressions = ctx.expression();
+                if (expressions.length > 0) {
+                    this.updateAfterPreviousTokenByContext(expressions[0], pipeContentIndent);
+                }
+            }
+            // Handle SORT BY
+            if (ctx.SORT()) {
+                if (!this.inPipeOperatorRightSide) {
+                    this.updateAfterPreviousTokenByNode(ctx.SORT(), this.newlineIndent);
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+                if (!this.inPipeOperatorRightSide) {
+                    this.addIndent();
+                }
+                const expressions = ctx.sortItem();
+                if (expressions.length > 0) {
+                    this.updateAfterPreviousTokenByContext(expressions[0], pipeContentIndent);
+                }
+            }
+            // Handle LIMIT - in pipe context, stays on same line as |>
+            if (ctx.LIMIT() && !this.inPipeOperatorRightSide) {
+                this.updateAfterPreviousTokenByNode(ctx.LIMIT(), this.newlineIndent);
+            }
+            // Handle OFFSET
+            if (ctx.OFFSET() && !this.inPipeOperatorRightSide) {
+                this.updateAfterPreviousTokenByNode(ctx.OFFSET(), this.newlineIndent);
+            }
+            super.visitChildren(ctx);
+            // Minus indent after processing (except in pipe context)
+            if (!this.inPipeOperatorRightSide && (ctx.ORDER() || ctx.CLUSTER() || ctx.DISTRIBUTE() || ctx.SORT())) {
+                this.minusIndent();
+            }
+        }
+    }
+    visitSortItem(ctx) {
+        // Format ASC/DESC - space before
+        if (ctx.ASC()) {
+            this.updateAfterPreviousTokenByNode(ctx.ASC(), ' ');
+        }
+        if (ctx.DESC()) {
+            this.updateAfterPreviousTokenByNode(ctx.DESC(), ' ');
+        }
+        // Format NULLS FIRST/LAST - space before NULLS
+        if (ctx.NULLS()) {
+            this.updateAfterPreviousTokenByNode(ctx.NULLS(), ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== Window Clause ====================
+    visitWindowClause(ctx) {
+        // In pipe context, WINDOW formatting is handled by PipeSelectStrategy
+        if (!this.inPipeOperatorRightSide) {
+            // WINDOW on new line with indent
+            this.updateAfterPreviousTokenByContext(ctx, this.newlineIndent);
+        }
+        // 判断是否为多窗口
+        const namedWindows = ctx.namedWindow();
+        const _isMultipleWindows = namedWindows.length > 1;
+        // 检查每个窗口是否为简单窗口（无窗口帧、无多参数）
+        const windowIsSimple = [];
+        for (const nw of namedWindows) {
+            const windowSpec = nw.windowSpec();
+            if (windowSpec instanceof SparkSQLParser_1.WindowDefContext) {
+                const hasWindowFrame = windowSpec.windowFrame();
+                const partitionExprs = windowSpec._partition || [];
+                const sortItems = windowSpec.sortItem();
+                const hasMultiplePartitionExprs = windowSpec.PARTITION() && partitionExprs.length > 1;
+                const hasMultipleSortItems = windowSpec.ORDER() && sortItems.length > 1;
+                // 简单窗口：无窗口帧、无多参数
+                windowIsSimple.push(!hasWindowFrame && !hasMultiplePartitionExprs && !hasMultipleSortItems);
+            }
+            else {
+                windowIsSimple.push(true); // WindowRef 视为简单
+            }
+        }
+        // 短句判断：单窗口且简单窗口
+        const isShortForm = namedWindows.length === 1 && windowIsSimple[0];
+        if (isShortForm) {
+            // 短句格式：WINDOW w AS (PARTITION BY dept ORDER BY date)
+            // 不添加缩进，不换行
+            this.inWindowClause = false; // 标记不在需要换行的 WINDOW 子句中
+            // 标记每个窗口定义是在 WINDOW 子句中
+            for (const nw of namedWindows) {
+                const windowSpec = nw.windowSpec();
+                if (windowSpec) {
+                    windowSpec._isInWindowClause = true;
+                }
+            }
+            super.visitChildren(ctx);
+        }
+        else {
+            // 长句格式
+            // WINDOW 后换行
+            const windowToken = ctx.WINDOW();
+            if (windowToken) {
+                this.updateBeforeNextTokenByNode(windowToken, this.newlineIndent);
+            }
+            this.addIndent();
+            // Format commas between window definitions - each window on separate line
+            const commas = ctx.COMMA();
+            for (let i = 0; i < commas.length; i++) {
+                const comma = commas[i];
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+            }
+            // 存储每个窗口是否简单的信息，供 visitWindowDef 使用
+            ctx._windowIsSimple = windowIsSimple;
+            ctx._currentWindowIndex = 0;
+            this.inWindowClause = true; // 标记在需要换行的 WINDOW 子句中
+            super.visitChildren(ctx);
+            this.minusIndent();
+        }
+    }
+    visitNamedWindow(ctx) {
+        // Format AS keyword - space before and after
+        this.normalizeKeywordSpacing(ctx.AS());
+        // 长句格式时，窗口名需要缩进 2 空格
+        if (this.inWindowClause) {
+            // 窗口名（identifier）前换行缩进
+            const identifier = ctx.errorCapturingIdentifier();
+            if (identifier) {
+                this.updateAfterPreviousTokenByContext(identifier, this.newlineIndent);
+            }
+        }
+        // 标记这是 WINDOW 子句中的窗口定义（而不是 OVER 子句）
+        const windowSpec = ctx.windowSpec();
+        if (windowSpec) {
+            windowSpec._isInWindowClause = true;
+        }
+        // 检查父级 WindowClauseContext 中是否有窗口简单性信息
+        const parentCtx = ctx.parent;
+        if (parentCtx && parentCtx._windowIsSimple && parentCtx._currentWindowIndex !== undefined) {
+            const idx = parentCtx._currentWindowIndex;
+            // 将当前窗口的简单性信息传递给 windowDef
+            if (windowSpec) {
+                windowSpec._isSimpleInMultiWindow = parentCtx._windowIsSimple[idx];
+            }
+            parentCtx._currentWindowIndex++;
+        }
+        super.visitChildren(ctx);
+    }
+    visitWindowDef(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        // Check if this is an empty window spec or has content
+        const hasPartition = ctx.PARTITION();
+        const hasDistribute = ctx.DISTRIBUTE();
+        const hasOrder = ctx.ORDER();
+        const hasSort = ctx.SORT();
+        const hasWindowFrame = ctx.windowFrame();
+        const hasContent = hasPartition || hasDistribute || hasOrder || hasSort || hasWindowFrame;
+        // In pipe context or for WINDOW clause definitions, use compact single-line format
+        // Example: WINDOW w as (partition by cate order by val)
+        const useCompactFormat = this.inPipeOperatorRightSide;
+        // 检查是否为简单窗口（用于 WINDOW 子句短句格式）
+        const partitionExprs = ctx._partition || [];
+        const sortItems = ctx.sortItem();
+        const hasMultiplePartitionExprs = ctx.PARTITION() && partitionExprs.length > 1;
+        const hasMultipleSortItems = ctx.ORDER() && sortItems.length > 1;
+        const isSimpleWindow = !hasWindowFrame && !hasMultiplePartitionExprs && !hasMultipleSortItems;
+        // 检查是否在多窗口场景下是简单窗口
+        const isSimpleInMultiWindow = ctx._isSimpleInMultiWindow;
+        // 短句格式判断：
+        // 只有在 WINDOW 子句中才能使用短句格式
+        // OVER 子句不使用短句格式
+        // 1. 在 WINDOW 子句中且不在长句格式（inWindowClause=false 表示单窗口简单场景）
+        // 2. 或者在多窗口场景下当前窗口是简单窗口
+        const isInWindowClause = this.inWindowClause || ctx._isInWindowClause;
+        const useShortFormat = isInWindowClause && !useCompactFormat && isSimpleWindow && hasContent && isSimpleInMultiWindow !== false;
+        if (useShortFormat && leftParen && rightParen) {
+            // 短句格式：WINDOW w AS (PARTITION BY dept ORDER BY date)
+            // 括号内容保持单行，紧凑格式
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            this.updateAfterPreviousTokenByNode(rightParen, '');
+            // Handle keywords with proper spacing
+            if (ctx.PARTITION()) {
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.PARTITION().symbol.startIndex);
+                if (prevToken && prevToken.text !== '(') {
+                    this.updateAfterPreviousTokenByNode(ctx.PARTITION(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            if (ctx.DISTRIBUTE()) {
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.DISTRIBUTE().symbol.startIndex);
+                if (prevToken && prevToken.text !== '(') {
+                    this.updateAfterPreviousTokenByNode(ctx.DISTRIBUTE(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            if (ctx.ORDER()) {
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.ORDER().symbol.startIndex);
+                if (prevToken && prevToken.text !== '(') {
+                    this.updateAfterPreviousTokenByNode(ctx.ORDER(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            if (ctx.SORT()) {
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.SORT().symbol.startIndex);
+                if (prevToken && prevToken.text !== '(') {
+                    this.updateAfterPreviousTokenByNode(ctx.SORT(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            super.visitChildren(ctx);
+        }
+        else if (useCompactFormat && leftParen && rightParen) {
+            // Compact format for pipe context - single line
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            this.updateAfterPreviousTokenByNode(rightParen, '');
+            // Handle keywords with proper spacing
+            // For PARTITION/ORDER etc, check if they are right after left paren
+            if (ctx.PARTITION()) {
+                // Check if PARTITION is right after left paren
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.PARTITION().symbol.startIndex);
+                if (prevToken && prevToken.text === '(') {
+                    // No space needed - it's right after left paren
+                }
+                else {
+                    this.updateAfterPreviousTokenByNode(ctx.PARTITION(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            if (ctx.DISTRIBUTE()) {
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.DISTRIBUTE().symbol.startIndex);
+                if (prevToken && prevToken.text !== '(') {
+                    this.updateAfterPreviousTokenByNode(ctx.DISTRIBUTE(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            if (ctx.ORDER()) {
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.ORDER().symbol.startIndex);
+                if (prevToken && prevToken.text !== '(') {
+                    this.updateAfterPreviousTokenByNode(ctx.ORDER(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            if (ctx.SORT()) {
+                const prevToken = this.getPreviousNonHiddenTokenByStartIndex(ctx.SORT().symbol.startIndex);
+                if (prevToken && prevToken.text !== '(') {
+                    this.updateAfterPreviousTokenByNode(ctx.SORT(), ' ');
+                }
+                const byTokens = ctx.BY();
+                for (const by of byTokens) {
+                    this.updateBeforeNextTokenByNode(by, ' ');
+                    this.updateAfterPreviousTokenByNode(by, ' ');
+                }
+            }
+            super.visitChildren(ctx);
+        }
+        else if (hasOrder && !hasPartition && !hasDistribute && !hasWindowFrame && leftParen && rightParen) {
+            // Simple OVER clause - use hanging indent format with ORDER BY on new line
+            // Format: OVER (
+            //           ORDER BY
+            //             col
+            //         )
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            // Add indent for content (total 4 spaces for PARTITION BY / ORDER BY)
+            this.addIndent();
+            // ORDER BY on new line with indent
+            const orderToken = ctx.ORDER();
+            if (orderToken) {
+                this.updateAfterPreviousTokenByNode(orderToken, this.newlineIndent);
+            }
+            // Space around BY keywords
+            const byTokens = ctx.BY();
+            for (const by of byTokens) {
+                this.updateAfterPreviousTokenByNode(by, ' ');
+            }
+            // ORDER BY 后的 sortItem 需要换行，缩进 6 空格 (4 + 2)
+            const sortItems = ctx.sortItem();
+            const hasMultipleSortItems = sortItems.length > 1;
+            if (sortItems.length > 0) {
+                // 添加额外缩进，使 sortItem 缩进 6 空格
+                this.addIndent();
+                // 在第一个 BY 后换行
+                if (byTokens.length > 0) {
+                    this.updateBeforeNextTokenByNode(byTokens[0], this.newlineIndent);
+                }
+                // 多参数时处理逗号换行
+                if (hasMultipleSortItems) {
+                    const commas = ctx.COMMA();
+                    for (const comma of commas) {
+                        this.updateAfterPreviousTokenByNode(comma, '');
+                        this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+                    }
+                }
+            }
+            super.visitChildren(ctx);
+            // 减去 sortItem 的额外缩进
+            if (sortItems.length > 0) {
+                this.minusIndent();
+            }
+            // Minus indent before right paren
+            this.minusIndent();
+            // Right paren on new line with 2-space indent
+            this.updateAfterPreviousTokenByNode(rightParen, this.newlineIndent);
+        }
+        else if (hasContent && leftParen && rightParen) {
+            // Complex window spec - format with hanging indent
+            // Left paren stays on same line
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            // Add indent for window spec content (content at 4 spaces)
+            this.addIndent();
+            // Handle PARTITION BY / DISTRIBUTE BY
+            // PARTITION BY 多参数时，表达式换行缩进 6 空格
+            // 注意：使用 _partition 数组获取 PARTITION BY 后的表达式数量
+            const partitionExprs = ctx._partition || [];
+            const hasMultiplePartitionExprs = ctx.PARTITION() && partitionExprs.length > 1;
+            // 收集所有 BY tokens
+            const allByTokens = ctx.BY();
+            let byIndex = 0;
+            if (ctx.PARTITION()) {
+                this.updateAfterPreviousTokenByNode(ctx.PARTITION(), this.newlineIndent);
+                // PARTITION BY 的 BY token
+                if (allByTokens.length > byIndex) {
+                    const partitionBy = allByTokens[byIndex];
+                    byIndex++;
+                    // BY 前面加空格（保持 PARTITION BY 在同一行）
+                    this.updateAfterPreviousTokenByNode(partitionBy, ' ');
+                    if (hasMultiplePartitionExprs) {
+                        // 先添加额外缩进使表达式缩进 6 空格
+                        this.addIndent();
+                        // 多参数时，BY 后换行（此时 newlineIndent 已经是 6 空格）
+                        this.updateBeforeNextTokenByNode(partitionBy, this.newlineIndent);
+                        // 处理逗号换行
+                        const commas = ctx.COMMA();
+                        for (const comma of commas) {
+                            this.updateAfterPreviousTokenByNode(comma, '');
+                            this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+                        }
+                    }
+                    else {
+                        // 单参数时，BY 后空格
+                        this.updateBeforeNextTokenByNode(partitionBy, ' ');
+                    }
+                }
+            }
+            if (ctx.DISTRIBUTE()) {
+                this.updateAfterPreviousTokenByNode(ctx.DISTRIBUTE(), this.newlineIndent);
+                if (allByTokens.length > byIndex) {
+                    const distributeBy = allByTokens[byIndex];
+                    byIndex++;
+                    this.updateAfterPreviousTokenByNode(distributeBy, ' ');
+                    this.updateBeforeNextTokenByNode(distributeBy, ' ');
+                }
+            }
+            // Handle ORDER BY / SORT BY
+            // ORDER BY 多参数时，sortItem 换行缩进 6 空格
+            const sortItems = ctx.sortItem();
+            const hasMultipleSortItems = ctx.ORDER() && sortItems.length > 1;
+            let hasOrderBy = false;
+            if (ctx.ORDER()) {
+                hasOrderBy = true;
+                // 先减去 PARTITION BY 多参数的额外缩进（如果有）
+                if (hasMultiplePartitionExprs) {
+                    this.minusIndent();
+                }
+                this.updateAfterPreviousTokenByNode(ctx.ORDER(), this.newlineIndent);
+                // ORDER BY 的 BY token
+                if (allByTokens.length > byIndex) {
+                    const orderBy = allByTokens[byIndex];
+                    byIndex++;
+                    // BY 前面加空格（保持 ORDER BY 在同一行）
+                    this.updateAfterPreviousTokenByNode(orderBy, ' ');
+                    // sortItem 换行，缩进 6 空格
+                    if (sortItems.length > 0) {
+                        // 先添加额外缩进使后续 sortItem 缩进 6 空格
+                        this.addIndent();
+                        // 在 BY 后换行
+                        this.updateBeforeNextTokenByNode(orderBy, this.newlineIndent);
+                        // 多参数时处理逗号换行
+                        if (hasMultipleSortItems) {
+                            const commas = ctx.COMMA();
+                            // 只处理 ORDER BY 相关的逗号（排除 PARTITION BY 的逗号）
+                            const partitionCommaCount = hasMultiplePartitionExprs ? partitionExprs.length - 1 : 0;
+                            for (let i = partitionCommaCount; i < commas.length; i++) {
+                                const comma = commas[i];
+                                this.updateAfterPreviousTokenByNode(comma, '');
+                                this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+                            }
+                        }
+                    }
+                    else {
+                        // 没有 sortItem 时，BY 后空格
+                        this.updateBeforeNextTokenByNode(orderBy, ' ');
+                    }
+                }
+            }
+            if (ctx.SORT()) {
+                // 先减去 PARTITION BY 多参数的额外缩进（如果有）
+                if (hasMultiplePartitionExprs && !hasOrderBy) {
+                    this.minusIndent();
+                }
+                this.updateAfterPreviousTokenByNode(ctx.SORT(), this.newlineIndent);
+                // SORT BY 的 BY token
+                if (allByTokens.length > byIndex) {
+                    const sortBy = allByTokens[byIndex];
+                    byIndex++;
+                    this.updateAfterPreviousTokenByNode(sortBy, ' ');
+                    this.updateBeforeNextTokenByNode(sortBy, ' ');
+                }
+            }
+            // 窗口帧 ROWS/RANGE BETWEEN 需要独立成行，缩进 4 空格
+            // 注意：如果前面有 ORDER BY sortItem，需要先减去 sortItem 的额外缩进
+            if (hasOrderBy && sortItems.length > 0) {
+                this.minusIndent();
+            }
+            super.visitChildren(ctx);
+            // 减去 PARTITION BY 多参数的额外缩进（如果没有 ORDER BY）
+            if (hasMultiplePartitionExprs && !ctx.ORDER() && !ctx.SORT()) {
+                this.minusIndent();
+            }
+            // Minus indent before right paren
+            this.minusIndent();
+            // Right paren on new line with 2-space indent
+            this.updateAfterPreviousTokenByNode(rightParen, this.newlineIndent);
+        }
+        else {
+            // Empty or simple window ref - compact format
+            if (leftParen) {
+                this.updateBeforeNextTokenByNode(leftParen, '');
+            }
+            if (rightParen) {
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+            }
+            super.visitChildren(ctx);
+        }
+    }
+    visitWindowFrame(ctx) {
+        // ROWS or RANGE - 独立成行，缩进 4 空格（与 PARTITION BY 同级）
+        if (ctx.ROWS()) {
+            this.updateAfterPreviousTokenByNode(ctx.ROWS(), this.newlineIndent);
+            this.updateBeforeNextTokenByNode(ctx.ROWS(), '');
+        }
+        if (ctx.RANGE()) {
+            this.updateAfterPreviousTokenByNode(ctx.RANGE(), this.newlineIndent);
+            this.updateBeforeNextTokenByNode(ctx.RANGE(), '');
+        }
+        // BETWEEN keyword - space after
+        if (ctx.BETWEEN()) {
+            this.updateAfterPreviousTokenByNode(ctx.BETWEEN(), ' ');
+        }
+        // AND keyword - space before and after
+        if (ctx.AND()) {
+            this.updateAfterPreviousTokenByNode(ctx.AND(), ' ');
+            this.updateBeforeNextTokenByNode(ctx.AND(), ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitFrameBound(ctx) {
+        // UNBOUNDED - space after
+        if (ctx.UNBOUNDED()) {
+            this.updateAfterPreviousTokenByNode(ctx.UNBOUNDED(), ' ');
+            this.updateBeforeNextTokenByNode(ctx.UNBOUNDED(), ' ');
+        }
+        // CURRENT - space after
+        if (ctx.CURRENT()) {
+            this.updateAfterPreviousTokenByNode(ctx.CURRENT(), ' ');
+            this.updateBeforeNextTokenByNode(ctx.CURRENT(), ' ');
+        }
+        // PRECEDING / FOLLOWING - space before
+        if (ctx.PRECEDING()) {
+            this.updateAfterPreviousTokenByNode(ctx.PRECEDING(), ' ');
+        }
+        if (ctx.FOLLOWING()) {
+            this.updateAfterPreviousTokenByNode(ctx.FOLLOWING(), ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== Grouping Analytics ====================
+    visitGroupingAnalytics(ctx) {
+        // ROLLUP, CUBE - put on new line after GROUP BY
+        if (ctx.ROLLUP()) {
+            this.updateAfterPreviousTokenByNode(ctx.ROLLUP(), this.newlineIndent);
+            this.updateBeforeNextTokenByNode(ctx.ROLLUP(), ' ');
+        }
+        if (ctx.CUBE()) {
+            this.updateAfterPreviousTokenByNode(ctx.CUBE(), this.newlineIndent);
+            this.updateBeforeNextTokenByNode(ctx.CUBE(), ' ');
+        }
+        // GROUPING SETS - put GROUPING on new line after GROUP BY
+        if (ctx.GROUPING()) {
+            this.updateAfterPreviousTokenByNode(ctx.GROUPING(), this.newlineIndent);
+            this.updateBeforeNextTokenByNode(ctx.GROUPING(), ' ');
+        }
+        if (ctx.SETS()) {
+            this.updateAfterPreviousTokenByNode(ctx.SETS(), ' ');
+            this.updateBeforeNextTokenByNode(ctx.SETS(), ' ');
+        }
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        // Get grouping sets or grouping elements
+        const _groupingSets = ctx.groupingSet();
+        const _groupingElements = ctx.groupingElement();
+        if (leftParen && rightParen) {
+            // Check content length to determine format
+            const contentLength = ctx.stop.stopIndex - ctx.start.startIndex;
+            const isLongContent = contentLength > this.maxParenthesisLength;
+            if (isLongContent) {
+                // Long content: each item on separate line
+                this.updateBeforeNextTokenByNode(leftParen, '');
+                this.addIndent();
+                // Format commas
+                const commas = ctx.COMMA();
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+                }
+                this.updateBeforeNextTokenByNode(rightParen, this.newlineIndent);
+                super.visitChildren(ctx);
+                this.minusIndent();
+            }
+            else {
+                // Short content: compact format on same line - no space inside parens
+                this.updateBeforeNextTokenByNode(leftParen, '');
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+                super.visitChildren(ctx);
+            }
+        }
+        else {
+            super.visitChildren(ctx);
+        }
+    }
+    visitGroupingSet(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen && rightParen) {
+            // Compact parentheses format - no extra spaces inside
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            this.updateAfterPreviousTokenByNode(rightParen, '');
+            // Format commas - space after, no space before
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, ' ');
+            }
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== PIVOT/UNPIVOT ====================
+    visitPivotClause(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        const namedExprSeq = ctx.namedExpressionSeq();
+        // Count aggregation expressions
+        const namedExpressions = namedExprSeq?.namedExpression() || [];
+        const hasMultipleAggregations = namedExpressions.length > 1;
+        // Check content length to determine format
+        const PIVOT_MAX_LENGTH = 80;
+        const contentLength = ctx.stop.stopIndex - ctx.start.startIndex;
+        const isLongContent = contentLength > PIVOT_MAX_LENGTH;
+        if (hasMultipleAggregations || isLongContent) {
+            // Multiple aggregations or long content: PIVOT on separate line with extra indent
+            // Format:
+            //   FROM
+            //     t
+            //       PIVOT (
+            //         SUM(amount) FOR year IN (
+            //           2020,
+            //           2021
+            //         )
+            //       );
+            // Or with multiple aggregations:
+            //   PIVOT (
+            //     SUM(a),
+            //     SUM(b) FOR year IN (
+            //       2020,
+            //       2021
+            //     )
+            //   );
+            this.addIndent();
+            this.updateAfterPreviousTokenByNode(ctx.PIVOT(), this.newlineIndent);
+            // Left paren after PIVOT - space before, newline + indent after
+            if (leftParen && leftParen.length > 0) {
+                this.updateAfterPreviousTokenByNode(leftParen[0], ' ');
+                this.addIndent();
+                this.updateBeforeNextTokenByNode(leftParen[0], this.newlineIndent);
+            }
+            // Format multiple aggregations - each on new line
+            if (hasMultipleAggregations && namedExprSeq) {
+                const commas = namedExprSeq.COMMA();
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+                }
+            }
+            // Format FOR keyword - space before and after
+            if (ctx.FOR()) {
+                this.updateAfterPreviousTokenByNode(ctx.FOR(), ' ');
+                this.updateBeforeNextTokenByNode(ctx.FOR(), ' ');
+            }
+            // Format IN keyword - space before and after
+            if (ctx.IN()) {
+                this.updateAfterPreviousTokenByNode(ctx.IN(), ' ');
+                this.updateBeforeNextTokenByNode(ctx.IN(), ' ');
+            }
+            // IN clause left paren - space before, newline + indent after
+            if (leftParen && leftParen.length > 1) {
+                this.updateAfterPreviousTokenByNode(leftParen[1], ' ');
+                this.addIndent();
+                this.updateBeforeNextTokenByNode(leftParen[1], this.newlineIndent);
+            }
+            // Format pivot values - each on new line
+            const pivotCommas = ctx.COMMA();
+            for (const comma of pivotCommas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+            }
+            // Right paren for IN clause - need to use direct edit for proper indent
+            if (rightParen && rightParen.length > 0) {
+                // IN right paren should align with 'SUM(amount) FOR year IN ('
+                // First minusIndent to go back to that level
+                this.minusIndent();
+                const inClosingIndent = this.newlineIndent;
+                this.bridge.collector.addEdit({
+                    range: {
+                        start: {
+                            line: rightParen[0].symbol.line - 1,
+                            character: rightParen[0].symbol.charPositionInLine
+                        },
+                        end: {
+                            line: rightParen[0].symbol.line - 1,
+                            character: rightParen[0].symbol.charPositionInLine
+                        }
+                    },
+                    newText: inClosingIndent
+                }, { level: 10, source: 'pivot-in-right-paren' });
+            }
+            // Right paren for PIVOT main - need to use direct edit for proper indent
+            if (rightParen && rightParen.length > 1) {
+                // PIVOT right paren should align with 'PIVOT ('
+                this.minusIndent();
+                const pivotClosingIndent = this.newlineIndent;
+                this.bridge.collector.addEdit({
+                    range: {
+                        start: {
+                            line: rightParen[1].symbol.line - 1,
+                            character: rightParen[1].symbol.charPositionInLine
+                        },
+                        end: {
+                            line: rightParen[1].symbol.line - 1,
+                            character: rightParen[1].symbol.charPositionInLine
+                        }
+                    },
+                    newText: pivotClosingIndent
+                }, { level: 10, source: 'pivot-right-paren' });
+            }
+            else if (rightParen && rightParen.length === 1) {
+                // Only one right paren (shouldn't happen but handle gracefully)
+                this.minusIndent();
+                const pivotClosingIndent = this.newlineIndent;
+                this.bridge.collector.addEdit({
+                    range: {
+                        start: {
+                            line: rightParen[0].symbol.line - 1,
+                            character: rightParen[0].symbol.charPositionInLine
+                        },
+                        end: {
+                            line: rightParen[0].symbol.line - 1,
+                            character: rightParen[0].symbol.charPositionInLine
+                        }
+                    },
+                    newText: pivotClosingIndent
+                }, { level: 10, source: 'pivot-right-paren' });
+            }
+            super.visitChildren(ctx);
+            this.minusIndent(); // PIVOT indent
+        }
+        else {
+            // Single aggregation, short content: PIVOT on same line as table
+            // Format: FROM t PIVOT (SUM(amount) FOR year IN (2020, 2021, 2022))
+            this.updateAfterPreviousTokenByNode(ctx.PIVOT(), ' ');
+            // Left paren after PIVOT - ensure space before, no space after
+            // Note: leftParen[0] is the main PIVOT parenthesis
+            // We need to handle the space between PIVOT and (
+            // updateAfterPreviousTokenByNode handles the space before leftParen[0]
+            // We don't need to call updateBeforeNextTokenByNode(leftParen[0]) because
+            // it would affect content after the paren
+            // Format FOR keyword
+            if (ctx.FOR()) {
+                this.updateAfterPreviousTokenByNode(ctx.FOR(), ' ');
+                this.updateBeforeNextTokenByNode(ctx.FOR(), ' ');
+            }
+            // Format IN keyword
+            if (ctx.IN()) {
+                this.updateAfterPreviousTokenByNode(ctx.IN(), ' ');
+                this.updateBeforeNextTokenByNode(ctx.IN(), ' ');
+            }
+            // IN clause parentheses - leftParen[1] is the IN parenthesis
+            // Ensure space before IN (
+            if (leftParen && leftParen.length > 1) {
+                this.updateAfterPreviousTokenByNode(leftParen[1], ' ');
+            }
+            // Right parens - no extra space
+            if (rightParen && rightParen.length > 0) {
+                this.updateAfterPreviousTokenByNode(rightParen[0], '');
+            }
+            if (rightParen && rightParen.length > 1) {
+                this.updateAfterPreviousTokenByNode(rightParen[1], '');
+            }
+            // Format pivot values - compact (comma space)
+            const pivotCommas = ctx.COMMA();
+            for (const comma of pivotCommas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, ' ');
+            }
+            // Skip strategy formatting for namedExpressionSeq in PIVOT - visit children directly
+            // This prevents unwanted newlines inside short PIVOT clauses
+            const children = ctx.children;
+            if (children) {
+                for (const child of children) {
+                    if (child instanceof ParserRuleContext_1.ParserRuleContext) {
+                        // Skip namedExpressionSeq - it's already formatted above
+                        if (child.constructor.name !== 'NamedExpressionSeqContext') {
+                            this.visit(child);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    visitUnpivotClause(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        const nullClause = ctx.unpivotNullClause();
+        // Check content length to determine format
+        const UNPIVOT_MAX_LENGTH = 80;
+        const contentLength = ctx.stop.stopIndex - ctx.start.startIndex;
+        const isLongContent = contentLength > UNPIVOT_MAX_LENGTH;
+        if (isLongContent) {
+            // Long content: UNPIVOT on separate line with extra indent
+            // Format:
+            //   FROM t
+            //     UNPIVOT INCLUDE NULLS (
+            //       val FOR col IN (
+            //         a,
+            //         b,
+            //         c
+            //       )
+            //     )
+            this.addIndent();
+            this.updateAfterPreviousTokenByNode(ctx.UNPIVOT(), this.newlineIndent);
+            // INCLUDE/EXCLUDE NULLS from nullClause
+            if (nullClause) {
+                if (nullClause.INCLUDE()) {
+                    this.updateAfterPreviousTokenByNode(nullClause.INCLUDE(), ' ');
+                    this.updateBeforeNextTokenByNode(nullClause.INCLUDE(), ' ');
+                }
+                if (nullClause.EXCLUDE()) {
+                    this.updateAfterPreviousTokenByNode(nullClause.EXCLUDE(), ' ');
+                    this.updateBeforeNextTokenByNode(nullClause.EXCLUDE(), ' ');
+                }
+                if (nullClause.NULLS()) {
+                    this.updateAfterPreviousTokenByNode(nullClause.NULLS(), ' ');
+                    this.updateBeforeNextTokenByNode(nullClause.NULLS(), ' ');
+                }
+            }
+            // Left paren - space before, newline + indent after
+            if (leftParen) {
+                this.updateAfterPreviousTokenByNode(leftParen, ' ');
+                // Add indent BEFORE newline so content inside has proper indent
+                this.addIndent();
+                this.updateBeforeNextTokenByNode(leftParen, this.newlineIndent);
+            }
+            else {
+                // No left paren, but still need indent for content
+                this.addIndent();
+            }
+            // Set flag for IN clause formatting
+            this.inUnpivotLongContent = true;
+            // Visit children to handle IN clause
+            const operator = ctx.unpivotOperator();
+            if (operator) {
+                this.visit(operator);
+            }
+            // Reset flag
+            this.inUnpivotLongContent = false;
+            // Right paren on new line - should have same indent as UNPIVOT line
+            if (rightParen) {
+                // UNPIVOT right paren should be at indent level 2 (4 spaces)
+                // Current level is 3 (after IN clause minusIndent), need to go to level 2
+                this.minusIndent();
+                const closingIndent = this.newlineIndent;
+                // Use direct edit since previous edit might conflict
+                this.bridge.collector.addEdit({
+                    range: {
+                        start: {
+                            line: rightParen.symbol.line - 1,
+                            character: rightParen.symbol.charPositionInLine
+                        },
+                        end: {
+                            line: rightParen.symbol.line - 1,
+                            character: rightParen.symbol.charPositionInLine
+                        }
+                    },
+                    newText: closingIndent
+                }, { level: 10, source: 'unpivot-right-paren' });
+            }
+            else {
+                this.minusIndent();
+            }
+            this.minusIndent(); // UNPIVOT indent
+        }
+        else {
+            // Short content: UNPIVOT on same line as table
+            this.updateAfterPreviousTokenByNode(ctx.UNPIVOT(), ' ');
+            // INCLUDE/EXCLUDE NULLS from nullClause
+            if (nullClause) {
+                if (nullClause.INCLUDE()) {
+                    this.updateAfterPreviousTokenByNode(nullClause.INCLUDE(), ' ');
+                    this.updateBeforeNextTokenByNode(nullClause.INCLUDE(), ' ');
+                }
+                if (nullClause.EXCLUDE()) {
+                    this.updateAfterPreviousTokenByNode(nullClause.EXCLUDE(), ' ');
+                    this.updateBeforeNextTokenByNode(nullClause.EXCLUDE(), ' ');
+                }
+                if (nullClause.NULLS()) {
+                    this.updateAfterPreviousTokenByNode(nullClause.NULLS(), ' ');
+                    this.updateBeforeNextTokenByNode(nullClause.NULLS(), ' ');
+                }
+            }
+            // Left paren - space before, no space after
+            if (leftParen) {
+                this.updateAfterPreviousTokenByNode(leftParen, ' ');
+            }
+            // Right paren - no extra space
+            if (rightParen) {
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+            }
+            super.visitChildren(ctx);
+        }
+    }
+    visitUnpivotSingleValueColumnClause(ctx) {
+        // Format: val FOR col IN (a, b, c)
+        const inToken = ctx.IN();
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        const commas = ctx.COMMA();
+        if (this.inUnpivotLongContent) {
+            // Format IN clause with newlines
+            // val FOR col IN (
+            //   a,
+            //   b,
+            //   c
+            // )
+            if (inToken) {
+                this.updateAfterPreviousTokenByNode(inToken, ' ');
+                this.updateBeforeNextTokenByNode(inToken, ' ');
+            }
+            if (leftParen) {
+                this.updateAfterPreviousTokenByNode(leftParen, ' ');
+                // Add indent before newline+indent for elements
+                this.addIndent();
+                this.updateBeforeNextTokenByNode(leftParen, this.newlineIndent);
+            }
+            // Commas - each element on new line with current indent
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+            }
+            if (rightParen) {
+                // IN clause right paren should align with 'val FOR col IN ('
+                // First minusIndent to go back to that level
+                this.minusIndent();
+                // Now save the indent for IN closing paren
+                const inClosingIndent = this.newlineIndent;
+                // Use direct edit to insert before the right paren
+                this.bridge.collector.addEdit({
+                    range: {
+                        start: {
+                            line: rightParen.symbol.line - 1,
+                            character: rightParen.symbol.charPositionInLine
+                        },
+                        end: {
+                            line: rightParen.symbol.line - 1,
+                            character: rightParen.symbol.charPositionInLine
+                        }
+                    },
+                    newText: inClosingIndent
+                }, { level: 10, source: 'unpivot-in-right-paren' });
+            }
+            // Visit children to format column names
+            super.visitChildren(ctx);
+        }
+        else {
+            // Compact format
+            if (inToken) {
+                this.updateAfterPreviousTokenByNode(inToken, ' ');
+                this.updateBeforeNextTokenByNode(inToken, ' ');
+            }
+            if (leftParen) {
+                this.updateAfterPreviousTokenByNode(leftParen, ' ');
+            }
+            if (rightParen) {
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+            }
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, ' ');
+            }
+            super.visitChildren(ctx);
+        }
+    }
+    visitUnpivotMultiValueColumnClause(ctx) {
+        // Similar handling for multi value column clause
+        super.visitChildren(ctx);
+    }
+    // ==================== Table Definition ====================
+    visitCreateFileFormat(ctx) {
+        // STORED AS or STORED BY
+        const storedNode = ctx.STORED();
+        const asNode = ctx.AS();
+        const byNode = ctx.BY();
+        if (storedNode) {
+            this.updateAfterPreviousTokenByNode(storedNode, this.newlineIndent);
+            this.updateBeforeNextTokenByNode(storedNode, ' ');
+        }
+        if (asNode) {
+            this.updateAfterPreviousTokenByNode(asNode, ' ');
+            this.updateBeforeNextTokenByNode(asNode, ' ');
+        }
+        if (byNode) {
+            this.updateAfterPreviousTokenByNode(byNode, ' ');
+            this.updateBeforeNextTokenByNode(byNode, ' ');
+        }
+        // Check for INPUTFORMAT/OUTPUTFORMAT (tableFileFormat)
+        const fileFormat = ctx.fileFormat();
+        if (fileFormat && fileFormat instanceof SparkSQLParser_1.TableFileFormatContext) {
+            const inputFormat = fileFormat.INPUTFORMAT();
+            const outputFormat = fileFormat.OUTPUTFORMAT();
+            const stringLits = fileFormat.stringLit();
+            // Check if line is too long - use stop/start position for accurate length
+            const contentLength = ctx.stop.stopIndex - ctx.start.startIndex;
+            const isLongContent = contentLength > this.maxParenthesisLength;
+            if (isLongContent) {
+                // Long content format:
+                // STORED AS INPUTFORMAT
+                //   'string'
+                // OUTPUTFORMAT
+                //   'string'
+                // INPUTFORMAT stays on same line as STORED AS
+                if (inputFormat) {
+                    this.updateAfterPreviousTokenByNode(inputFormat, ' ');
+                    this.updateBeforeNextTokenByNode(inputFormat, ' ');
+                }
+                // String value on new line with indent
+                if (stringLits.length > 0) {
+                    this.addIndent();
+                    this.updateAfterPreviousTokenByContext(stringLits[0], this.newlineIndent);
+                    this.minusIndent();
+                }
+                // OUTPUTFORMAT on new line (no extra indent)
+                if (outputFormat) {
+                    this.updateAfterPreviousTokenByNode(outputFormat, this.newlineIndent);
+                    this.updateBeforeNextTokenByNode(outputFormat, ' ');
+                }
+                // String value on new line with indent
+                if (stringLits.length > 1) {
+                    this.addIndent();
+                    this.updateAfterPreviousTokenByContext(stringLits[1], this.newlineIndent);
+                    this.minusIndent();
+                }
+            }
+            else {
+                // Short content: all on same line with spaces
+                if (inputFormat) {
+                    this.updateAfterPreviousTokenByNode(inputFormat, ' ');
+                    this.updateBeforeNextTokenByNode(inputFormat, ' ');
+                }
+                if (outputFormat) {
+                    this.updateAfterPreviousTokenByNode(outputFormat, ' ');
+                    this.updateBeforeNextTokenByNode(outputFormat, ' ');
+                }
+            }
+        }
+        super.visitChildren(ctx);
+    }
+    visitBucketSpec(ctx) {
+        // CLUSTERED BY
+        const clusteredNode = ctx.CLUSTERED();
+        const byTokens = ctx.BY();
+        if (clusteredNode) {
+            this.updateAfterPreviousTokenByNode(clusteredNode, ' ');
+            this.updateBeforeNextTokenByNode(clusteredNode, ' ');
+        }
+        if (byTokens.length > 0) {
+            this.updateAfterPreviousTokenByNode(byTokens[0], ' ');
+            this.updateBeforeNextTokenByNode(byTokens[0], ' ');
+        }
+        // SORTED BY (optional)
+        const sortedNode = ctx.SORTED();
+        if (sortedNode && byTokens.length > 1) {
+            this.updateAfterPreviousTokenByNode(sortedNode, ' ');
+            this.updateBeforeNextTokenByNode(sortedNode, ' ');
+            this.updateAfterPreviousTokenByNode(byTokens[1], ' ');
+            this.updateBeforeNextTokenByNode(byTokens[1], ' ');
+        }
+        // INTO n BUCKETS
+        const intoNode = ctx.INTO();
+        const bucketsNode = ctx.BUCKETS();
+        if (intoNode) {
+            this.updateAfterPreviousTokenByNode(intoNode, ' ');
+            this.updateBeforeNextTokenByNode(intoNode, ' ');
+        }
+        if (bucketsNode) {
+            this.updateAfterPreviousTokenByNode(bucketsNode, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitSample(ctx) {
+        const tablesample = ctx.TABLESAMPLE();
+        const repeatable = ctx.REPEATABLE();
+        const leftParens = ctx.LEFT_PAREN();
+        const rightParens = ctx.RIGHT_PAREN();
+        // TABLESAMPLE - space after
+        if (tablesample) {
+            this.updateAfterPreviousTokenByNode(tablesample, ' ');
+            this.updateBeforeNextTokenByNode(tablesample, ' ');
+        }
+        // Parentheses - compact format
+        for (const leftParen of leftParens) {
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            this.updateAfterPreviousTokenByNode(leftParen, '');
+        }
+        for (const rightParen of rightParens) {
+            this.updateAfterPreviousTokenByNode(rightParen, '');
+        }
+        // REPEATABLE - space before and after
+        if (repeatable) {
+            this.updateAfterPreviousTokenByNode(repeatable, ' ');
+            this.updateBeforeNextTokenByNode(repeatable, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== CASE WHEN Expression ====================
+    visitSearchedCase(ctx) {
+        const _caseNode = ctx.CASE();
+        const endNode = ctx.END();
+        const elseNode = ctx.ELSE();
+        const whenClauses = ctx.whenClause();
+        const elseExpr = ctx.expression();
+        // 增加 CASE 内部缩进（WHEN/ELSE 使用）
+        this.addIndent();
+        // 手动处理每个 WHEN 子句
+        for (let i = 0; i < whenClauses.length; i++) {
+            const whenClause = whenClauses[i];
+            const thenNode = whenClause.THEN();
+            const expressions = whenClause.expression();
+            // 每个 WHEN 前换行（包括第一个），这样 CASE 后自动换行
+            this.updateAfterPreviousTokenByContext(whenClause, this.newlineIndent);
+            // 检查 THEN 后是否是嵌套 CASE WHEN
+            const resultExpr = expressions && expressions.length > 1 ? expressions[1] : null;
+            const isNestedCase = resultExpr && this.isCaseWhenExpression(resultExpr);
+            if (isNestedCase) {
+                // 嵌套 CASE 特殊格式：WHEN 条件换行
+                // 先增加缩进用于条件表达式
+                this.addIndent();
+                const whenNode = whenClause.WHEN();
+                if (whenNode) {
+                    // WHEN 后换行 + 缩进（此时缩进已增加）
+                    this.updateBeforeNextTokenByNode(whenNode, this.newlineIndent);
+                }
+                // 访问条件表达式
+                if (expressions && expressions.length > 0) {
+                    this.visit(expressions[0]);
+                }
+                // 减少缩进（回到 CASE 内部缩进）
+                this.minusIndent();
+                // THEN 独占一行
+                if (thenNode) {
+                    // THEN 前换行（使用当前 CASE 内部缩进）
+                    this.updateAfterPreviousTokenByNode(thenNode, this.newlineIndent);
+                    // THEN 后换行：先增加缩进，再设置
+                    this.addIndent();
+                    this.updateBeforeNextTokenByNode(thenNode, this.newlineIndent);
+                }
+                // 访问嵌套 CASE 结果表达式
+                if (expressions && expressions.length > 1) {
+                    this.visit(expressions[1]);
+                }
+                // 减少缩进（THEN 后增加的）
+                if (thenNode) {
+                    this.minusIndent();
+                }
+            }
+            else {
+                // 普通格式：WHEN 条件不换行
+                const whenNode = whenClause.WHEN();
+                if (whenNode) {
+                    // WHEN 后空格
+                    this.updateBeforeNextTokenByNode(whenNode, ' ');
+                }
+                // 访问条件表达式
+                if (expressions && expressions.length > 0) {
+                    this.visit(expressions[0]);
+                }
+                // THEN 前后空格
+                if (thenNode) {
+                    this.updateBeforeNextTokenByNode(thenNode, ' ');
+                    // THEN 后空格
+                    this.updateAfterPreviousTokenByNode(thenNode, ' ');
+                }
+                // 访问结果表达式
+                if (expressions && expressions.length > 1) {
+                    this.visit(expressions[1]);
+                }
+            }
+        }
+        // ELSE 前换行
+        if (elseNode) {
+            this.updateAfterPreviousTokenByNode(elseNode, this.newlineIndent);
+        }
+        // 访问 ELSE 后的表达式
+        if (elseExpr) {
+            this.visit(elseExpr);
+        }
+        // 减少 CASE 内部缩进
+        this.minusIndent();
+        // END 前换行（恢复到 CASE 同级缩进）
+        if (endNode) {
+            this.updateAfterPreviousTokenByNode(endNode, this.newlineIndent);
+        }
+    }
+    /**
+     * 检查表达式是否是 CASE WHEN 表达式
+     */
+    isCaseWhenExpression(ctx) {
+        // 检查当前节点类型
+        const className = ctx.constructor.name;
+        if (className === 'SearchedCaseContext' || className === 'SimpleCaseContext') {
+            return true;
+        }
+        // 递归检查子节点（因为 CASE WHEN 可能在括号内或其他表达式中）
+        if (ctx.childCount > 0) {
+            for (let i = 0; i < ctx.childCount; i++) {
+                const child = ctx.getChild(i);
+                if (child instanceof ParserRuleContext_1.ParserRuleContext) {
+                    if (this.isCaseWhenExpression(child)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    visitSimpleCase(ctx) {
+        const caseNode = ctx.CASE();
+        const endNode = ctx.END();
+        const elseNode = ctx.ELSE();
+        const whenClauses = ctx.whenClause();
+        const expressions = ctx.expression();
+        // CASE 后空格（保留 case 值表达式在同一行）
+        if (caseNode) {
+            this.updateBeforeNextTokenByNode(caseNode, ' ');
+        }
+        // 访问 case 值表达式（第一个表达式）
+        if (expressions && expressions.length > 0) {
+            this.visit(expressions[0]);
+        }
+        // 增加 CASE 内部缩进（WHEN/ELSE 使用）
+        this.addIndent();
+        // 手动处理每个 WHEN 子句
+        for (const whenClause of whenClauses) {
+            const thenNode = whenClause.THEN();
+            const whenExprs = whenClause.expression();
+            // 每个 WHEN 前换行
+            this.updateAfterPreviousTokenByContext(whenClause, this.newlineIndent);
+            // 检查 THEN 后是否是嵌套 CASE WHEN
+            const resultExpr = whenExprs && whenExprs.length > 1 ? whenExprs[1] : null;
+            const isNestedCase = resultExpr && this.isCaseWhenExpression(resultExpr);
+            if (isNestedCase) {
+                // 嵌套 CASE 特殊格式：WHEN 值换行
+                // 先增加缩进用于 WHEN 值表达式
+                this.addIndent();
+                const whenNode = whenClause.WHEN();
+                if (whenNode) {
+                    // WHEN 后换行 + 缩进（此时缩进已增加）
+                    this.updateBeforeNextTokenByNode(whenNode, this.newlineIndent);
+                }
+                // 访问 WHEN 值表达式
+                if (whenExprs && whenExprs.length > 0) {
+                    this.visit(whenExprs[0]);
+                }
+                // 减少缩进（回到 CASE 内部缩进）
+                this.minusIndent();
+                // THEN 独占一行
+                if (thenNode) {
+                    // THEN 前换行（使用当前 CASE 内部缩进）
+                    this.updateAfterPreviousTokenByNode(thenNode, this.newlineIndent);
+                    // THEN 后换行：先增加缩进，再设置
+                    this.addIndent();
+                    this.updateBeforeNextTokenByNode(thenNode, this.newlineIndent);
+                }
+                // 访问嵌套 CASE 结果表达式
+                if (whenExprs && whenExprs.length > 1) {
+                    this.visit(whenExprs[1]);
+                }
+                // 减少缩进（THEN 后增加的）
+                if (thenNode) {
+                    this.minusIndent();
+                }
+            }
+            else {
+                // 普通格式：WHEN 值不换行
+                const whenNode = whenClause.WHEN();
+                if (whenNode) {
+                    // WHEN 后空格
+                    this.updateBeforeNextTokenByNode(whenNode, ' ');
+                }
+                // 访问 WHEN 值表达式
+                if (whenExprs && whenExprs.length > 0) {
+                    this.visit(whenExprs[0]);
+                }
+                // THEN 前后空格
+                if (thenNode) {
+                    this.updateBeforeNextTokenByNode(thenNode, ' ');
+                    // THEN 后空格
+                    this.updateAfterPreviousTokenByNode(thenNode, ' ');
+                }
+                // 访问结果表达式
+                if (whenExprs && whenExprs.length > 1) {
+                    this.visit(whenExprs[1]);
+                }
+            }
+        }
+        // ELSE 前换行
+        if (elseNode) {
+            this.updateAfterPreviousTokenByNode(elseNode, this.newlineIndent);
+        }
+        // 访问 ELSE 后的表达式
+        if (expressions && expressions.length > 1) {
+            this.visit(expressions[1]);
+        }
+        // 减少 CASE 内部缩进
+        this.minusIndent();
+        // END 前换行（恢复到 CASE 同级缩进）
+        if (endNode) {
+            this.updateAfterPreviousTokenByNode(endNode, this.newlineIndent);
+        }
+    }
+    visitWhenClause(_ctx) {
+        // WHEN/THEN 的空格在 visitSearchedCase/visitSimpleCase 中处理
+        // 这里不调用 super.visitChildren(ctx)，因为子节点已经在上层处理过了
+    }
+    visitSetOperation(ctx) {
+        // UNION, INTERSECT, EXCEPT, SETMINUS should be on their own line
+        const unionNode = ctx.UNION();
+        const intersectNode = ctx.INTERSECT();
+        const exceptNode = ctx.EXCEPT();
+        const setminusNode = ctx.SETMINUS();
+        const operatorNode = unionNode || intersectNode || exceptNode || setminusNode;
+        if (operatorNode) {
+            // Operator keyword on new line
+            this.updateAfterPreviousTokenByNode(operatorNode, this.newlineIndent);
+        }
+        // Handle setQuantifier (ALL/DISTINCT) - it should stay on same line as operator
+        const setQuantifier = ctx.setQuantifier();
+        if (setQuantifier) {
+            // Space before ALL/DISTINCT
+            this.updateAfterPreviousTokenByContext(setQuantifier, ' ');
+            // Newline after ALL/DISTINCT, before right query
+            this.updateBeforeNextTokenByContext(setQuantifier, this.newlineIndent);
+        }
+        // Right query should start on new line after UNION ALL / UNION / etc.
+        // Only add newline if there's no setQuantifier (otherwise it's handled above)
+        const rightQuery = ctx._right;
+        if (rightQuery && !setQuantifier) {
+            this.updateAfterPreviousTokenByContext(rightQuery, this.newlineIndent);
+        }
+        super.visitChildren(ctx);
+    }
+    visitSetQuantifier(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitNamedExpressionSeq(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitNamedExpression(ctx) {
+        // Format AS keyword - ensure space before and after
+        this.normalizeKeywordSpacing(ctx.AS());
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== Column Type ====================
+    visitColType(ctx) {
+        // Single space between column name (identifier) and data type
+        const dataType = ctx.dataType();
+        if (dataType) {
+            this.updateAfterPreviousTokenByContext(dataType, ' ');
+        }
+        // Handle COMMENT when there's no dataType - add space after column identifier
+        const commentSpec = ctx.commentSpec();
+        const identifier = ctx.errorCapturingIdentifier();
+        if (!dataType && commentSpec && identifier) {
+            // Add space after column identifier before COMMENT
+            this.updateAfterPreviousTokenByContext(identifier, ' ');
+        }
+        // Handle NOT NULL
+        const errorCapturingNot = ctx.errorCapturingNot();
+        const nullNode = ctx.NULL();
+        if (errorCapturingNot && nullNode) {
+            this.updateAfterPreviousTokenByContext(errorCapturingNot, ' ');
+            this.updateBeforeNextTokenByContext(errorCapturingNot, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== JOIN ====================
+    visitJoinRelation(ctx) {
+        const bridge = this.getJoinFormattingBridge();
+        const target = {
+            joinContext: ctx,
+            naturalKeyword: ctx.NATURAL() || undefined,
+            joinKeyword: ctx.JOIN(),
+            lateralKeyword: ctx.LATERAL() || undefined
+        };
+        if (this.inPipeOperatorRightSide) {
+            strategies_1.coreStrategies.join.formatJoinEntry(target, bridge, { separatorBeforeJoin: ' ' });
+            super.visitChildren(ctx);
+            return;
+        }
+        // Check if there is ON clause (not USING - USING should stay on same line)
+        const joinCriteria = ctx.joinCriteria();
+        const hasOnClause = joinCriteria && joinCriteria.ON();
+        // Check if NATURAL JOIN (no ON clause needed)
+        const isNaturalJoin = ctx.NATURAL() !== null && ctx.NATURAL() !== undefined;
+        // Check if CROSS JOIN (no ON clause needed)
+        const joinType = ctx.joinType();
+        const isCrossJoin = joinType && joinType.CROSS() !== null && joinType.CROSS() !== undefined;
+        // Check if this JOIN is right after a closing parenthesis (inside parentheses)
+        let isAfterClosingParen = false;
+        if (isCrossJoin || isNaturalJoin) {
+            const joinKeyword = ctx.JOIN();
+            if (joinKeyword) {
+                const _prevToken = this.getPreviousNonHiddenTokenByStartIndex(joinKeyword.symbol.startIndex);
+                // Check if previous token is ) or the token before JOIN keyword is )
+                // For CROSS JOIN, need to check before CROSS keyword
+                const crossKeyword = joinType?.CROSS();
+                const naturalKeyword = ctx.NATURAL();
+                const checkToken = crossKeyword || naturalKeyword || joinKeyword;
+                if (checkToken) {
+                    const tokenBeforeJoin = this.getPreviousNonHiddenTokenByStartIndex(checkToken.symbol.startIndex);
+                    isAfterClosingParen = tokenBeforeJoin?.text === ')';
+                }
+            }
+        }
+        if (hasOnClause) {
+            // Has ON: JOIN should be on new line with extra indent
+            // Rule: JOIN relative to table name +1 indent level (total 2 levels, 4 spaces)
+            this.addIndent();
+            strategies_1.coreStrategies.join.formatJoinEntry(target, bridge, { separatorBeforeJoin: this.newlineIndent });
+            super.visitChildren(ctx);
+            this.minusIndent();
+        }
+        else if (isAfterClosingParen) {
+            // JOIN after closing parenthesis inside parentheses: should be on new line with indent
+            this.addIndent();
+            strategies_1.coreStrategies.join.formatJoinEntry(target, bridge, { separatorBeforeJoin: this.newlineIndent });
+            super.visitChildren(ctx);
+            this.minusIndent();
+        }
+        else if (isNaturalJoin || isCrossJoin) {
+            // NATURAL or CROSS JOIN: stays on same line as previous table
+            // Rule 6: No ON, JOIN does not break line
+            strategies_1.coreStrategies.join.formatJoinEntry(target, bridge, { separatorBeforeJoin: ' ' });
+            super.visitChildren(ctx);
+        }
+        else {
+            // Other JOINs without ON (may have USING or no criteria)
+            // Check for USING - stays on same line
+            const hasUsingClause = joinCriteria && joinCriteria.USING();
+            if (hasUsingClause) {
+                strategies_1.coreStrategies.join.formatJoinEntry(target, bridge, { separatorBeforeJoin: ' ' });
+                super.visitChildren(ctx);
+            }
+            else {
+                // No criteria at all - check if this is expected or error
+                // For now, treat as no line break
+                strategies_1.coreStrategies.join.formatJoinEntry(target, bridge, { separatorBeforeJoin: ' ' });
+                super.visitChildren(ctx);
+            }
+        }
+    }
+    visitJoinType(ctx) {
+        if (ctx.LEFT())
+            this.updateBeforeNextTokenByNode(ctx.LEFT(), ' ');
+        if (ctx.RIGHT())
+            this.updateBeforeNextTokenByNode(ctx.RIGHT(), ' ');
+        if (ctx.FULL())
+            this.updateBeforeNextTokenByNode(ctx.FULL(), ' ');
+        if (ctx.OUTER()) {
+            this.updateAfterPreviousTokenByNode(ctx.OUTER(), ' ');
+            this.updateBeforeNextTokenByNode(ctx.OUTER(), ' ');
+        }
+        if (ctx.INNER())
+            this.updateBeforeNextTokenByNode(ctx.INNER(), ' ');
+        if (ctx.CROSS())
+            this.updateBeforeNextTokenByNode(ctx.CROSS(), ' ');
+        if (ctx.SEMI()) {
+            this.updateAfterPreviousTokenByNode(ctx.SEMI(), ' ');
+            this.updateBeforeNextTokenByNode(ctx.SEMI(), ' ');
+        }
+        if (ctx.ANTI()) {
+            this.updateAfterPreviousTokenByNode(ctx.ANTI(), ' ');
+            this.updateBeforeNextTokenByNode(ctx.ANTI(), ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitJoinCriteria(ctx) {
+        const bridge = this.getJoinFormattingBridge();
+        const target = {
+            criteriaContext: ctx,
+            usingKeyword: ctx.USING() || undefined,
+            onKeyword: ctx.ON() || undefined,
+            bodyStart: (ctx.booleanExpression() || ctx.identifierList()) ?? undefined
+        };
+        if (this.inPipeOperatorRightSide) {
+            // In pipe context: ON should be on new line with pipe content indent
+            if (ctx.ON()) {
+                strategies_1.coreStrategies.join.formatJoinCriteriaEntry(target, bridge, {
+                    separatorBeforeCriteriaKeyword: this.context.getPipeContentIndent(),
+                    separatorAfterCriteriaKeyword: ' '
+                });
+            }
+            else {
+                // USING clause: stays on same line
+                strategies_1.coreStrategies.join.formatJoinCriteriaEntry(target, bridge, {
+                    separatorBeforeCriteriaKeyword: ' ',
+                    separatorAfterCriteriaKeyword: ''
+                });
+            }
+            super.visitChildren(ctx);
+            return;
+        }
+        // ON clause: should be on new line with extra indent (relative to JOIN)
+        // Rule: ON relative to JOIN +1 indent level (total 3 levels, 6 spaces)
+        if (ctx.ON()) {
+            this.addIndent();
+            // Check if the ON clause starts with a parenthesized expression
+            const booleanExpr = ctx.booleanExpression();
+            const startsWithParen = booleanExpr && this.expressionStartsWithParen(booleanExpr);
+            if (startsWithParen) {
+                // ON (condition): keep space after ON, let ParenthesisStrategy handle the paren
+                strategies_1.coreStrategies.join.formatJoinCriteriaEntry(target, bridge, {
+                    separatorBeforeCriteriaKeyword: this.newlineIndent,
+                    separatorAfterCriteriaKeyword: ' '
+                });
+            }
+            else {
+                // Normal ON clause: space after ON
+                strategies_1.coreStrategies.join.formatJoinCriteriaEntry(target, bridge, {
+                    separatorBeforeCriteriaKeyword: this.newlineIndent,
+                    separatorAfterCriteriaKeyword: ' '
+                });
+            }
+            super.visitChildren(ctx);
+            this.minusIndent();
+        }
+        else {
+            // USING clause: stays on same line as JOIN
+            // Rule 6: No ON, does not break line
+            strategies_1.coreStrategies.join.formatJoinCriteriaEntry(target, bridge, {
+                separatorBeforeCriteriaKeyword: ' ',
+                separatorAfterCriteriaKeyword: ''
+            });
+            super.visitChildren(ctx);
+        }
+    }
+    expressionStartsWithParen(expr) {
+        // Check if expression starts with a parenthesis
+        const text = expr.text || '';
+        return text.trimStart().startsWith('(');
+    }
+    visitLateralView(ctx) {
+        if (this.inPipeOperatorRightSide) {
+            super.visitChildren(ctx);
+            return;
+        }
+        // LATERAL VIEW on new line with one level indent (relative to FROM)
+        // Get the previous token (should be the end of relation or previous lateral view)
+        const lateralToken = ctx.LATERAL();
+        if (lateralToken) {
+            // Find the previous non-hidden token
+            const prevToken = this.getPreviousNonHiddenToken(lateralToken.symbol.tokenIndex);
+            if (prevToken) {
+                // Insert newline + indent between previous token and LATERAL
+                const prevEndPos = this.getTokenEndPosition(prevToken);
+                // Use high priority to ensure this edit is not overridden
+                this.bridge.collector.addEdit({
+                    range: {
+                        start: prevEndPos,
+                        end: { line: lateralToken.symbol.line - 1, character: lateralToken.symbol.charPositionInLine }
+                    },
+                    newText: this.newlineIndent
+                }, { level: 10, source: 'lateralView' });
+            }
+        }
+        const viewToken = ctx.VIEW();
+        const outerToken = ctx.OUTER();
+        if (lateralToken && viewToken) {
+            // Skip updateAfterPreviousTokenByNode(lateralToken) - already handled by newline+indent above
+            this.updateBeforeNextTokenByNode(viewToken, ' ');
+            this.updateAfterPreviousTokenByNode(viewToken, ' ');
+        }
+        if (outerToken) {
+            this.updateAfterPreviousTokenByNode(outerToken, ' ');
+            this.updateBeforeNextTokenByNode(outerToken, ' ');
+        }
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen && rightParen) {
+            this.updateAfterPreviousTokenByNode(leftParen, '');
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            this.updateAfterPreviousTokenByNode(rightParen, '');
+            const leftParenIndex = leftParen.symbol.tokenIndex;
+            const rightParenIndex = rightParen.symbol.tokenIndex;
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                const commaIndex = comma.symbol.tokenIndex;
+                if (commaIndex > leftParenIndex && commaIndex < rightParenIndex) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, ' ');
+                }
+            }
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== INSERT/UPDATE/DELETE/MERGE ====================
+    visitSingleInsertQuery(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitInsertIntoTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitInsertOverwriteTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitInsertOverwriteHiveDir(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitInsertOverwriteDir(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDeleteFromTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitUpdateTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitSetClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitMergeIntoTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitMatchedClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitNotMatchedClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitNotMatchedBySourceClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== Utility Statements ====================
+    visitExplain(ctx) {
+        const explainNode = ctx.EXPLAIN();
+        const modeNode = ctx.LOGICAL() || ctx.FORMATTED() || ctx.EXTENDED() || ctx.CODEGEN() || ctx.COST();
+        if (modeNode) {
+            this.updateBeforeNextTokenByNode(explainNode, ' ');
+            this.updateBeforeNextTokenByNode(modeNode, this.newline);
+        }
+        else {
+            this.updateBeforeNextTokenByNode(explainNode, this.newline);
+        }
+        super.visitChildren(ctx);
+    }
+    visitCall(ctx) {
+        const callKeyword = ctx.CALL();
+        this.updateBeforeNextTokenByNode(callKeyword, ' ');
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen && rightParen) {
+            this.updateAfterPreviousTokenByNode(leftParen, '');
+            const args = ctx.functionArgument();
+            const argsLength = args.map(a => a.text).join(', ').length;
+            if (argsLength > this.maxParenthesisLength) {
+                this.addIndent();
+                if (args.length > 0) {
+                    this.updateAfterPreviousTokenByContext(args[0], this.newlineIndent);
+                }
+                const commas = ctx.COMMA();
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+                }
+                this.minusIndent();
+                this.updateAfterPreviousTokenByNode(rightParen, this.newline);
+            }
+            else {
+                const commas = ctx.COMMA();
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, ' ');
+                }
+            }
+        }
+        super.visitChildren(ctx);
+    }
+    visitExecuteImmediate(ctx) {
+        const executeNode = ctx.EXECUTE();
+        const immediateNode = ctx.IMMEDIATE();
+        this.updateBeforeNextTokenByNode(executeNode, ' ');
+        this.updateBeforeNextTokenByNode(immediateNode, ' ');
+        const intoNode = ctx.INTO();
+        if (intoNode) {
+            this.updateAfterPreviousTokenByNode(intoNode, this.newline);
+            this.updateBeforeNextTokenByNode(intoNode, ' ');
+        }
+        const targetVariable = ctx.multipartIdentifierList();
+        if (targetVariable) {
+            const commas = targetVariable.COMMA();
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, ' ');
+            }
+        }
+        const usingClause = ctx.executeImmediateUsing();
+        if (usingClause) {
+            this.visitExecuteImmediateUsing(usingClause);
+        }
+        super.visitChildren(ctx);
+    }
+    visitExecuteImmediateUsing(ctx) {
+        const usingNode = ctx.USING();
+        this.updateAfterPreviousTokenByNode(usingNode, this.newline);
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen && rightParen) {
+            const paramsSeq = ctx.namedExpressionSeq();
+            const params = paramsSeq.namedExpression();
+            const paramsLength = params.map(p => p.text).join(', ').length;
+            if (paramsLength > this.maxParenthesisLength) {
+                this.addIndent();
+                this.updateBeforeNextTokenByNode(leftParen, this.newlineIndent);
+                this.updateAfterPreviousTokenByNode(rightParen, this.newlineIndent);
+                this.minusIndent();
+            }
+            else {
+                this.updateAfterPreviousTokenByNode(leftParen, ' ');
+                this.updateBeforeNextTokenByNode(leftParen, '');
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+            }
+        }
+        else {
+            this.updateBeforeNextTokenByNode(usingNode, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitCommentNamespace(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCommentTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDescribeFunction(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDescribeProcedure(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDescribeNamespace(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDescribeRelation(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDescribeQuery(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitAnalyze(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitAnalyzeTables(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRepairTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitTruncateTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCacheTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitUncacheTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitClearCache(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRefreshTable(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRefreshFunction(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitLoadData(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== Expression ====================
+    visitFunctionCall(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCast(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitTrim(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitAny_value(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitFirst(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitLast(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitTimestampadd(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitTimestampdiff(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitPosition(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitStruct(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitLogicalBinary(ctx) {
+        // In pipe context, use pipe-specific indent for AND/OR
+        const indentForAndOr = this.inPipeOperatorRightSide ? this.context.getPipeContentIndent() : this.newlineIndent;
+        // Format AND/OR on new line with indent
+        if (ctx.AND()) {
+            this.updateAfterPreviousTokenByNode(ctx.AND(), indentForAndOr);
+            this.updateBeforeNextTokenByNode(ctx.AND(), ' ');
+        }
+        if (ctx.OR()) {
+            this.updateAfterPreviousTokenByNode(ctx.OR(), indentForAndOr);
+            this.updateBeforeNextTokenByNode(ctx.OR(), ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitLogicalNot(ctx) {
+        // Space after NOT (but NOT before - that's handled by parent context like WHERE)
+        if (ctx.NOT()) {
+            this.updateBeforeNextTokenByNode(ctx.NOT(), ' ');
+        }
+        if (ctx.BANG()) {
+            this.updateBeforeNextTokenByNode(ctx.BANG(), ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitComparison(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitPredicate(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCollateClause(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCollate(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitArithmeticBinary(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitIntervalValue(ctx) {
+        // Add space before interval value if preceded by INTERVAL keyword
+        const prevToken = this.getPreviousNonHiddenToken(ctx.start.tokenIndex);
+        if (prevToken?.type === SparkSQLLexer_1.SparkSQLLexer.INTERVAL) {
+            this.updateAfterPreviousTokenByContext(ctx, ' ');
+        }
+        // Handle MINUS sign with spaces
+        const minus = ctx.MINUS();
+        if (minus) {
+            this.updateAfterPreviousTokenByNode(minus, ' ');
+            this.updateBeforeNextTokenByNode(minus, ' ');
+        }
+        // Add space after the value before the unit
+        const integerValue = ctx.INTEGER_VALUE();
+        const decimalValue = ctx.DECIMAL_VALUE();
+        const stringLit = ctx.stringLit();
+        if (integerValue) {
+            this.updateBeforeNextTokenByNode(integerValue, ' ');
+        }
+        else if (decimalValue) {
+            this.updateBeforeNextTokenByNode(decimalValue, ' ');
+        }
+        else if (stringLit && !minus) {
+            this.updateBeforeNextTokenByContext(stringLit, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitSubqueryExpression(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitSubquery(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitParenthesizedExpression(ctx) {
+        // Check if this parenthesized expression is inside an InlineTable (VALUES clause)
+        // For InlineTable, preserve space between VALUES keyword and left paren
+        // The space was already added by visitInlineTable, so skip strategy formatting
+        let isInInlineTable = false;
+        let parent = ctx.parent;
+        while (parent) {
+            if (parent.constructor.name === 'InlineTableContext') {
+                isInInlineTable = true;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (isInInlineTable) {
+            // Don't use strategy - it would override the space after VALUES
+            // Just format the right paren, but NOT the left paren
+            const rightParen = ctx.RIGHT_PAREN();
+            if (rightParen) {
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+            }
+            super.visitChildren(ctx);
+        }
+        else if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitExists(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== Inline Table ====================
+    visitInlineTableDefault2(ctx) {
+        // InlineTable in FROM clause - visit inlineTable child directly
+        // This ensures InlineTable sees InlineTableDefault2Context as its parent
+        const inlineTable = ctx.inlineTable();
+        if (inlineTable) {
+            // Mark that this is FROM VALUES context
+            inlineTable.__isFromValues = true;
+        }
+        super.visitChildren(ctx);
+    }
+    visitInlineTable(ctx) {
+        // VALUES clause formatting
+        const valuesToken = ctx.VALUES();
+        const _expressions = ctx.expression();
+        const tableAlias = ctx.tableAlias();
+        if (!valuesToken) {
+            super.visitChildren(ctx);
+            return;
+        }
+        // Check if this is inside an INSERT statement or CREATE VIEW AS VALUES
+        let parent = ctx.parent;
+        let isInsideInsert = false;
+        let isAfterCreateViewAs = false;
+        let isInsideFromClause = false;
+        // First check for FROM clause context
+        let p = ctx.parent;
+        while (p) {
+            if (p.constructor.name === 'FromClauseContext') {
+                isInsideFromClause = true;
+                break;
+            }
+            if (p.constructor.name === 'InlineTableDefault2Context') {
+                isInsideFromClause = true;
+                break;
+            }
+            p = p.parent;
+        }
+        // Then check for INSERT or CREATE VIEW AS VALUES
+        parent = ctx.parent;
+        while (parent) {
+            if (parent.constructor.name === 'SingleInsertQueryContext') {
+                isInsideInsert = true;
+                break;
+            }
+            // Only set isAfterCreateViewAs if VALUES is directly after AS (not in FROM clause)
+            if (parent.constructor.name === 'CreateViewContext' && !isInsideFromClause) {
+                isAfterCreateViewAs = true;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (isInsideInsert) {
+            // Inside INSERT - VALUES on new line with 2-space indent
+            this.updateAfterPreviousTokenByNode(valuesToken, '\n  ');
+            const expressions = ctx.expression();
+            const _commas = ctx.COMMA();
+            if (expressions.length > 1) {
+                // Multiple tuples - each on separate line with additional indent
+                this.addIndent();
+                // Mark inlineTable as long content for visitRowConstructor
+                ctx.__isLongContent = true;
+                // VALUES 后换行，所有元组在独立行
+                this.updateBeforeNextTokenByNode(valuesToken, this.newlineIndent);
+                // 在每个后续元组前添加换行+缩进
+                for (let i = 1; i < expressions.length; i++) {
+                    const expr = expressions[i];
+                    // 使用 updateAfterPreviousTokenByContext 在元组前设置换行
+                    this.updateAfterPreviousTokenByContext(expr, this.newlineIndent);
+                }
+                super.visitChildren(ctx);
+                this.minusIndent();
+            }
+            else {
+                // Single tuple - on same line as VALUES
+                this.updateBeforeNextTokenByNode(valuesToken, ' ');
+                super.visitChildren(ctx);
+            }
+        }
+        else if (isAfterCreateViewAs) {
+            // Inside CREATE VIEW AS VALUES - VALUES on new line
+            // The newline after AS is already handled by CreateViewStrategy
+            // Only need to add space after VALUES keyword
+            this.updateBeforeNextTokenByNode(valuesToken, ' ');
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, ' ');
+            }
+            super.visitChildren(ctx);
+        }
+        else {
+            // Not inside INSERT or CREATE VIEW AS VALUES
+            // Check if this is a VALUES statement as pipe start (TABLE statement)
+            // This is the case when VALUES appears at the start of a pipe expression
+            let isPipeStart = false;
+            let p = ctx.parent;
+            while (p) {
+                if (p.constructor.name === 'TableStatementContext' || p.constructor.name === 'OperatorPipeStatementContext') {
+                    isPipeStart = true;
+                    break;
+                }
+                // VALUES in InlineTableDefault1Context can be pipe start
+                if (p.constructor.name === 'InlineTableDefault1Context') {
+                    isPipeStart = true;
+                    break;
+                }
+                p = p.parent;
+            }
+            // Check if content is long enough to require multiline formatting
+            // For InlineTable, use ctx.text.length to match Legacy behavior (compressed text length)
+            const contentLength = ctx.text.length;
+            const isLongContent = contentLength > this.maxParenthesisLength || isPipeStart;
+            const expressions = ctx.expression();
+            if (isLongContent) {
+                // Long content - use multiline format with each tuple on separate line
+                // Add indent first so newlineIndent has proper indent for VALUES
+                this.addIndent();
+                // For pipe start, VALUES is the first token, set newline after it
+                // For FROM VALUES, set newline before VALUES
+                if (isPipeStart) {
+                    // VALUES is first token - set newline after VALUES
+                    this.updateBeforeNextTokenByNode(valuesToken, this.newlineIndent);
+                }
+                else {
+                    // VALUES is after FROM - set newline before VALUES
+                    this.updateAfterPreviousTokenByNode(valuesToken, this.newlineIndent);
+                }
+                // First tuple on new line after VALUES (same indent as VALUES content)
+                // Format tuple-level commas: comma stays at end of line, next tuple on new line
+                const commas = ctx.COMMA();
+                for (let i = 0; i < commas.length; i++) {
+                    const comma = commas[i];
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    // Next tuple on new line
+                    if (expressions.length > i + 1) {
+                        this.updateAfterPreviousTokenByContext(expressions[i + 1], this.newlineIndent);
+                    }
+                }
+                // Mark inlineTable as long content for visitRowConstructor
+                ctx.__isLongContent = true;
+                super.visitChildren(ctx);
+                this.minusIndent(); // Remove VALUES indent
+            }
+            else {
+                // Short content - compact format
+                // VALUES on new line with indent after FROM
+                this.addIndent();
+                this.updateAfterPreviousTokenByNode(valuesToken, this.newlineIndent);
+                this.updateBeforeNextTokenByNode(valuesToken, ' ');
+                // Legacy uses formatInlineCommaNodes for tuple-level commas
+                const commas = ctx.COMMA();
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, ' ');
+                }
+                super.visitChildren(ctx);
+                this.minusIndent();
+            }
+        }
+        // Handle table alias with AS keyword - AS should never have newline before it
+        if (tableAlias) {
+            this.normalizeKeywordSpacing(tableAlias.AS());
+        }
+    }
+    visitRowConstructor(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen && rightParen) {
+            // Check if this row constructor is inside an inlineTable (VALUES clause)
+            let inlineTableCtx = null;
+            let p = ctx.parent;
+            while (p) {
+                if (p.constructor.name === 'InlineTableContext') {
+                    inlineTableCtx = p;
+                    break;
+                }
+                p = p.parent;
+            }
+            const isInInlineTable = inlineTableCtx !== null;
+            const isLongContent = inlineTableCtx?.__isLongContent;
+            const contentLength = ctx.text.length;
+            const commas = ctx.COMMA();
+            // For RowConstructor inside InlineTable with long content:
+            // Keep tuple compact, don't modify space before left paren
+            // (space/newline was already set by visitInlineTable)
+            if (isInInlineTable && isLongContent) {
+                // Compact format: only handle inside parens
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+                // Internal commas: compact
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, ' ');
+                }
+                super.visitChildren(ctx);
+            }
+            else {
+                this.formatParenthesizedContent(leftParen, rightParen, commas, contentLength, {
+                    forceCompact: true,
+                    spaceBeforeLeftParen: isInInlineTable,
+                    visitChildren: () => super.visitChildren(ctx)
+                });
+            }
+        }
+        else {
+            super.visitChildren(ctx);
+        }
+    }
+    // ==================== Aliased Query/Relation (FROM 后子查询) ====================
+    /**
+     * Format aliased query (FROM 后的括号子查询)
+     * 规则：左括号换行，内容缩进 2 空格，右括号与 FROM 对齐
+     *
+     * 例如：
+     * FROM
+     *   (
+     *     SELECT ...
+     *   ) AS alias
+     */
+    visitAliasedQuery(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        const query = ctx.query();
+        const tableAlias = ctx.tableAlias();
+        if (!leftParen || !rightParen) {
+            super.visitChildren(ctx);
+            return;
+        }
+        // 左括号换行
+        this.updateBeforeNextTokenByNode(leftParen, this.newlineIndent);
+        // 增加缩进（子查询内容缩进 2 空格）
+        this.addIndent();
+        // 子查询内容换行
+        if (query) {
+            this.updateAfterPreviousTokenByContext(query, this.newlineIndent);
+        }
+        // 访问子查询
+        if (query) {
+            this.visit(query);
+        }
+        // 减少缩进
+        this.minusIndent();
+        // 右括号换行（与 FROM 对齐）
+        this.updateAfterPreviousTokenByNode(rightParen, this.newlineIndent);
+        // 处理别名 - 与右括号同行
+        if (tableAlias) {
+            const asNode = tableAlias.AS();
+            if (asNode) {
+                this.updateAfterPreviousTokenByNode(asNode, ' ');
+                this.updateBeforeNextTokenByNode(asNode, ' ');
+            }
+            this.visit(tableAlias);
+        }
+        // 处理 sample 和 watermarkClause
+        const sample = ctx.sample();
+        if (sample) {
+            this.visit(sample);
+        }
+        const watermarkClause = ctx.watermarkClause();
+        if (watermarkClause) {
+            this.visit(watermarkClause);
+        }
+    }
+    /**
+     * Format aliased relation (FROM 后的括号关系)
+     * 规则：左括号换行，内容缩进 2 空格，右括号与 FROM 对齐
+     */
+    visitAliasedRelation(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        const relation = ctx.relation();
+        const tableAlias = ctx.tableAlias();
+        if (!leftParen || !rightParen) {
+            super.visitChildren(ctx);
+            return;
+        }
+        // 左括号换行
+        this.updateBeforeNextTokenByNode(leftParen, this.newlineIndent);
+        // 增加缩进（括号内容缩进 2 空格）
+        this.addIndent();
+        // 关系内容换行
+        if (relation) {
+            this.updateAfterPreviousTokenByContext(relation, this.newlineIndent);
+        }
+        // 访问关系
+        if (relation) {
+            this.visit(relation);
+        }
+        // 减少缩进
+        this.minusIndent();
+        // 右括号换行（与 FROM 对齐）
+        this.updateAfterPreviousTokenByNode(rightParen, this.newlineIndent);
+        // 处理别名 - 与右括号同行
+        if (tableAlias) {
+            const asNode = tableAlias.AS();
+            if (asNode) {
+                this.updateAfterPreviousTokenByNode(asNode, ' ');
+                this.updateBeforeNextTokenByNode(asNode, ' ');
+            }
+            this.visit(tableAlias);
+        }
+        // 处理 sample 和 watermarkClause
+        const sample = ctx.sample();
+        if (sample) {
+            this.visit(sample);
+        }
+        const watermarkClause = ctx.watermarkClause();
+        if (watermarkClause) {
+            this.visit(watermarkClause);
+        }
+    }
+    visitTableAlias(ctx) {
+        const strictIdentifier = ctx.strictIdentifier();
+        if (strictIdentifier) {
+            this.updateAfterPreviousTokenByContext(strictIdentifier, ' ');
+        }
+        const identifierList = ctx.identifierList();
+        if (identifierList) {
+            const leftParen = identifierList.LEFT_PAREN();
+            if (leftParen) {
+                this.updateAfterPreviousTokenByNode(leftParen, '');
+            }
+        }
+        super.visitChildren(ctx);
+    }
+    visitIdentifierList(ctx) {
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (leftParen && rightParen) {
+            const isInsideTableAlias = ctx.parent?.constructor?.name === 'TableAliasContext';
+            const identifierSeq = ctx.identifierSeq();
+            const commas = identifierSeq?.COMMA() || [];
+            const contentLength = ctx.stop.stopIndex - ctx.start.startIndex;
+            if (contentLength > this.maxParenthesisLength) {
+                this.addIndent();
+                this.updateBeforeNextTokenByNode(leftParen, this.newlineIndent);
+                this.updateAfterPreviousTokenByNode(rightParen, this.newlineIndent);
+                this.minusIndent();
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+                }
+            }
+            else {
+                if (!isInsideTableAlias) {
+                    this.updateAfterPreviousTokenByNode(leftParen, ' ');
+                }
+                this.updateBeforeNextTokenByNode(leftParen, '');
+                this.updateAfterPreviousTokenByNode(rightParen, '');
+                for (const comma of commas) {
+                    this.updateAfterPreviousTokenByNode(comma, '');
+                    this.updateBeforeNextTokenByNode(comma, ' ');
+                }
+            }
+        }
+        super.visitChildren(ctx);
+    }
+    visitIdentifierSeq(ctx) {
+        if (ctx.parent?.constructor?.name === 'IdentifierListContext') {
+            super.visitChildren(ctx);
+            return;
+        }
+        const commas = ctx.COMMA();
+        for (const comma of commas) {
+            this.updateAfterPreviousTokenByNode(comma, '');
+            this.updateBeforeNextTokenByNode(comma, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== Partition ====================
+    visitPartitionSpec(ctx) {
+        const partitionNode = ctx.PARTITION();
+        const leftParen = ctx.LEFT_PAREN();
+        const rightParen = ctx.RIGHT_PAREN();
+        if (partitionNode && leftParen && rightParen) {
+            this.updateBeforeNextTokenByNode(partitionNode, ' ');
+            this.updateBeforeNextTokenByNode(leftParen, '');
+            this.updateAfterPreviousTokenByNode(rightParen, '');
+            const commas = ctx.COMMA();
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, ' ');
+            }
+        }
+        super.visitChildren(ctx);
+    }
+    visitPartitionVal(ctx) {
+        const eqNode = ctx.EQ();
+        if (eqNode) {
+            this.updateAfterPreviousTokenByNode(eqNode, ' ');
+            this.updateBeforeNextTokenByNode(eqNode, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== Table ====================
+    visitTable(ctx) {
+        const tableToken = ctx.TABLE();
+        if (tableToken) {
+            this.updateBeforeNextTokenByNode(tableToken, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitTableName(ctx) {
+        const tableAlias = ctx.tableAlias();
+        if (tableAlias) {
+            this.normalizeKeywordSpacing(tableAlias.AS());
+        }
+        super.visitChildren(ctx);
+    }
+    // ==================== Pipe Operator ====================
+    visitOperatorPipeStatement(ctx) {
+        const operatorPipeNode = ctx.OPERATOR_PIPE();
+        const pipeNode = ctx.PIPE();
+        const operatorNode = operatorPipeNode || pipeNode;
+        if (operatorNode) {
+            // `|> KEYWORD` should be on the same line (no newline before KEYWORD)
+            // Just ensure space before and after `|>`
+            this.updateAfterPreviousTokenByNode(operatorNode, '\n');
+            this.updateBeforeNextTokenByNode(operatorNode, ' ');
+        }
+        super.visitChildren(ctx);
+    }
+    visitOperatorPipeRightSide(ctx) {
+        // Save state
+        const savedInPipeOperatorRightSide = this.inPipeOperatorRightSide;
+        this.inPipeOperatorRightSide = true;
+        // Sync state to FormattingContext so strategies can check via bridge.context.inPipeOperatorRightSide
+        this.context.enterPipeContext();
+        // Get pipe step kind and apply appropriate strategy
+        const stepKind = this.getPipeStepKind(ctx);
+        const formatting = {
+            savedIndentNumber: this.context.currentIndentLevel,
+            savedIndentString: ' ',
+            previousInPipeOperatorRightSide: savedInPipeOperatorRightSide,
+            newline: this.newline,
+            newlineIndent: this.newlineIndent
+        };
+        switch (stepKind) {
+            case 'pipe.select':
+                strategies_1.coreStrategies.pipeSelect.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.where':
+                strategies_1.coreStrategies.pipeWhere.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.set':
+                strategies_1.coreStrategies.pipeSet.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.drop':
+                strategies_1.coreStrategies.pipeDrop.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.extend':
+                strategies_1.coreStrategies.pipeExtend.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.join':
+                strategies_1.coreStrategies.pipeJoin.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.aggregate':
+                strategies_1.coreStrategies.pipeAggregate.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.setOperation':
+                strategies_1.coreStrategies.pipeSetOperation.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.queryOrganization':
+                strategies_1.coreStrategies.pipeQueryOrganization.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.sample':
+                strategies_1.coreStrategies.pipeSample.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.pivot':
+                strategies_1.coreStrategies.pipePivot.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            case 'pipe.unpivot':
+                strategies_1.coreStrategies.pipeUnpivot.apply(ctx, this.getPipeStepBridge(), formatting);
+                break;
+            default:
+                super.visitChildren(ctx);
+        }
+        // Restore state
+        this.inPipeOperatorRightSide = savedInPipeOperatorRightSide;
+        this.context.exitPipeContext();
+    }
+    // ==================== Helper Methods ====================
+    get indent() {
+        return this.context.indent;
+    }
+    get newlineIndent() {
+        return this.context.newlineIndent;
+    }
+    addIndent() {
+        this.context.addIndent();
+    }
+    minusIndent() {
+        this.context.minusIndent();
+    }
+    addTextEdit(edit) {
+        this.editCollector.addEdit(edit);
+    }
+    updateAfterPreviousTokenByContext(ctx, newText) {
+        this.bridge.updateAfterPreviousTokenByContext(ctx, newText);
+    }
+    updateAfterPreviousTokenByNode(node, newText) {
+        this.bridge.updateAfterPreviousTokenByNode(node, newText);
+    }
+    updateBeforeNextTokenByNode(node, newText) {
+        this.bridge.updateBeforeNextTokenByNode(node, newText);
+    }
+    updateBeforeNextTokenByContext(ctx, newText) {
+        this.bridge.updateBeforeNextTokenByContext(ctx, newText);
+    }
+    getPreviousNonHiddenToken(tokenIndex) {
+        return this.bridge.getPreviousNonHiddenToken(tokenIndex);
+    }
+    getPreviousNonHiddenTokenByStartIndex(startIndex) {
+        return this.bridge.getPreviousNonHiddenTokenByStartIndex(startIndex);
+    }
+    getNextNonHiddenToken(tokenIndex) {
+        return this.bridge.getNextNonHiddenToken(tokenIndex);
+    }
+    getTokenEndPosition(token) {
+        return this.bridge.getTokenEndPosition(token);
+    }
+    findCommentTokensBetween(startIndex, endIndex) {
+        return this.bridge.findCommentTokensBetween(startIndex, endIndex);
+    }
+    /**
+     * Normalize keyword spacing - ensure single space before and after
+     * Used for keywords like AS, VALUES, TABLE, etc.
+     */
+    normalizeKeywordSpacing(node) {
+        if (!node) {
+            return;
+        }
+        this.updateAfterPreviousTokenByNode(node, ' ');
+        this.updateBeforeNextTokenByNode(node, ' ');
+    }
+    /**
+     * Normalize multiple keywords at once
+     */
+    normalizeKeywordsSpacing(...nodes) {
+        for (const node of nodes) {
+            this.normalizeKeywordSpacing(node);
+        }
+    }
+    // ==================== Legacy Helper Methods Migration ====================
+    /**
+     * Add space after a node (shorthand for common pattern)
+     */
+    addSpaceAfterNode(node) {
+        if (node) {
+            this.updateBeforeNextTokenByNode(node, ' ');
+        }
+    }
+    /**
+     * Add space after a context (shorthand for common pattern)
+     */
+    addSpaceAfterContext(ctx) {
+        if (ctx) {
+            this.updateBeforeNextTokenByContext(ctx, ' ');
+        }
+    }
+    /**
+     * Add space after multiple nodes (batch operation)
+     */
+    addSpaceAfterNodes(...nodes) {
+        for (const node of nodes) {
+            if (node) {
+                this.updateBeforeNextTokenByNode(node, ' ');
+            }
+        }
+    }
+    /**
+     * Add newline before a node
+     */
+    addNewlineBeforeNode(node) {
+        if (node) {
+            this.updateAfterPreviousTokenByNode(node, this.newline);
+        }
+    }
+    /**
+     * Add newline after a node
+     */
+    addNewlineAfterNode(node) {
+        if (node) {
+            this.updateBeforeNextTokenByNode(node, this.newline);
+        }
+    }
+    /**
+     * Add newline with indent before a node
+     */
+    addNewlineIndentBeforeNode(node) {
+        if (node) {
+            this.updateAfterPreviousTokenByNode(node, this.newlineIndent);
+        }
+    }
+    /**
+     * Add newline before a context
+     */
+    addNewlineBeforeContext(ctx) {
+        if (ctx) {
+            this.updateAfterPreviousTokenByContext(ctx, this.newline);
+        }
+    }
+    /**
+     * Add newline with indent before a context
+     */
+    addNewlineIndentBeforeContext(ctx) {
+        if (ctx) {
+            this.updateAfterPreviousTokenByContext(ctx, this.newlineIndent);
+        }
+    }
+    /**
+     * Add indent and put node on new line with indent
+     */
+    indentAfterNode(node) {
+        if (!node) {
+            return;
+        }
+        this.addIndent();
+        this.updateBeforeNextTokenByNode(node, this.newlineIndent);
+        this.minusIndent();
+    }
+    /**
+     * Format compact parentheses (no newlines inside)
+     */
+    formatCompactParentheses(leftParen, rightParen, options) {
+        if (!leftParen || !rightParen) {
+            return;
+        }
+        const spaceBeforeLeftParen = options?.spaceBeforeLeftParen ?? false;
+        if (spaceBeforeLeftParen) {
+            this.updateAfterPreviousTokenByNode(leftParen, ' ');
+        }
+        this.updateBeforeNextTokenByNode(leftParen, '');
+        this.updateAfterPreviousTokenByNode(rightParen, '');
+        if (options?.commas) {
+            this.formatInlineCommaNodes(options.commas);
+        }
+    }
+    /**
+     * Format inline comma nodes - comma stays at end with space after
+     */
+    formatInlineCommaNodes(commas) {
+        for (const comma of commas) {
+            this.updateAfterPreviousTokenByNode(comma, '');
+            this.updateBeforeNextTokenByNode(comma, ' ');
+        }
+    }
+    /**
+     * Get bridge for BlockStrategy formatting
+     */
+    getBlockFormattingBridge() {
+        return {
+            updateAfterPreviousTokenByNode: (node, newText) => this.updateAfterPreviousTokenByNode(node, newText),
+            updateBeforeNextTokenByNode: (node, newText) => this.updateBeforeNextTokenByNode(node, newText),
+            updateAfterPreviousTokenByContext: (ctx, newText) => this.updateAfterPreviousTokenByContext(ctx, newText)
+        };
+    }
+    /**
+     * Format parenthesized content with automatic line length detection
+     */
+    formatParenthesizedContent(leftParen, rightParen, commas, contentLength, options) {
+        if (!leftParen || !rightParen) {
+            options?.visitChildren?.();
+            return;
+        }
+        const opts = options || {};
+        const useMultiline = opts.forceMultiline || (!opts.forceCompact && contentLength > this.maxParenthesisLength);
+        const bridge = this.getBlockFormattingBridge();
+        if (useMultiline) {
+            if (opts.addIndentBeforeFormat) {
+                this.addIndent();
+            }
+            this.addIndent();
+            this.blockStrategy.formatMultilineBlock({ leftParen, rightParen }, bridge, {
+                spaceBeforeLeftParen: opts.spaceBeforeLeftParen,
+                separatorAfterLeftParen: this.newlineIndent,
+                separatorBeforeRightParen: this.newlineIndent
+            });
+            for (const comma of commas) {
+                this.updateAfterPreviousTokenByNode(comma, '');
+                this.updateBeforeNextTokenByNode(comma, this.newlineIndent);
+            }
+            opts.visitChildren?.();
+            this.minusIndent();
+            this.addNewlineIndentBeforeNode(rightParen);
+            if (opts.addIndentBeforeFormat) {
+                this.minusIndent();
+            }
+        }
+        else {
+            this.blockStrategy.formatCompactBlock({ leftParen, rightParen }, bridge, {
+                spaceBeforeLeftParen: opts.spaceBeforeLeftParen,
+                separatorAfterLeftParen: '',
+                separatorBeforeRightParen: ''
+            });
+            this.formatInlineCommaNodes(commas);
+            opts.visitChildren?.();
+        }
+    }
+    /**
+     * Post-process: normalize keyword spacing in final output
+     * This catches any keywords that weren't handled by visitor methods
+     */
+    normalizeAllKeywordSpacing() {
+        // Keywords that need space before and after (when not at line start)
+        const keywordsNeedingSpace = [
+            'AS',
+            'VALUES',
+            'TABLE',
+            'VIEW',
+            'INDEX',
+            'FUNCTION',
+            'INNER',
+            'LEFT',
+            'RIGHT',
+            'FULL',
+            'OUTER',
+            'CROSS',
+            'NATURAL',
+            'UNION',
+            'INTERSECT',
+            'EXCEPT',
+            'JOIN',
+            'ON',
+            'AND',
+            'OR',
+            'NOT',
+            'ORDER',
+            'GROUP',
+            'BY',
+            'HAVING',
+            'LIMIT',
+            'OFFSET',
+            'WHERE',
+            'FROM',
+            'SELECT',
+            'INSERT',
+            'UPDATE',
+            'DELETE',
+            'CREATE',
+            'ALTER',
+            'DROP',
+            'SET',
+            'INTO',
+            'OVERWRITE'
+        ];
+        const allTokens = this.tokens.getTokens();
+        for (let i = 0; i < allTokens.length; i++) {
+            const token = allTokens[i];
+            const tokenText = token.text?.toUpperCase();
+            if (token.channel !== 0)
+                continue;
+            if (!tokenText || !keywordsNeedingSpace.includes(tokenText))
+                continue;
+            // Skip if no edits were made near this token (it was already handled by visitor)
+            const tokenLine = token.line - 1;
+            const tokenStart = token.charPositionInLine;
+            const tokenEnd = tokenStart + (token.text?.length || 0);
+            // Check if there's already an edit for this token's surrounding whitespace
+            if (this.editCollector.hasOverlappingEdit(tokenLine, tokenStart - 1, tokenLine, tokenEnd + 1)) {
+                continue;
+            }
+            // Ensure space before keyword (unless at line start or after newline)
+            if (i > 0) {
+                const prevToken = allTokens[i - 1];
+                if (prevToken.channel === 1 && prevToken.text && !prevToken.text.includes('\n')) {
+                    // Previous is whitespace on same line - ensure single space
+                    if (!prevToken.text.endsWith(' ')) {
+                        const prevStartChar = prevToken.charPositionInLine;
+                        const prevEndChar = prevStartChar + prevToken.text.length;
+                        if (!this.editCollector.hasOverlappingEdit(prevToken.line - 1, prevStartChar, prevToken.line - 1, prevEndChar)) {
+                            this.editCollector.addEdit({
+                                range: {
+                                    start: { line: prevToken.line - 1, character: prevStartChar },
+                                    end: { line: prevToken.line - 1, character: prevEndChar }
+                                },
+                                newText: `${prevToken.text} `
+                            });
+                        }
+                    }
+                }
+            }
+            // Ensure space after keyword
+            if (i + 1 < allTokens.length) {
+                const nextToken = allTokens[i + 1];
+                if (nextToken.channel === 1 && nextToken.text && !nextToken.text.includes('\n')) {
+                    // Next is whitespace on same line - ensure single space
+                    if (!nextToken.text.startsWith(' ')) {
+                        const nextStartChar = nextToken.charPositionInLine;
+                        const nextEndChar = nextStartChar + nextToken.text.length;
+                        if (!this.editCollector.hasOverlappingEdit(nextToken.line - 1, nextStartChar, nextToken.line - 1, nextEndChar)) {
+                            this.editCollector.addEdit({
+                                range: {
+                                    start: { line: nextToken.line - 1, character: nextStartChar },
+                                    end: { line: nextToken.line - 1, character: nextEndChar }
+                                },
+                                newText: ` ${nextToken.text}`
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    compressConsecutiveSpaces() {
+        const allTokens = this.tokens.getTokens();
+        for (const token of allTokens) {
+            // Skip non-whitespace tokens (channel 1 is HIDDEN/whitespace)
+            if (token.channel !== 1)
+                continue;
+            // Skip comment tokens (they are also on HIDDEN channel but should not be modified)
+            if (token.type === SparkSQLLexer_1.SparkSQLLexer.SIMPLE_COMMENT || token.type === SparkSQLLexer_1.SparkSQLLexer.BRACKETED_COMMENT) {
+                continue;
+            }
+            const text = token.text;
+            if (!text)
+                continue;
+            const startLine = token.line - 1;
+            const startChar = token.charPositionInLine;
+            const endChar = startChar + text.length;
+            if (this.editCollector.hasOverlappingEdit(startLine, startChar, startLine, endChar))
+                continue;
+            // Rule 1: Compress multiple spaces to single space (no newlines)
+            if (!text.includes('\n') && !text.includes('\r') && text.includes('  ')) {
+                this.editCollector.addEdit({
+                    range: {
+                        start: { line: startLine, character: startChar },
+                        end: { line: startLine, character: endChar }
+                    },
+                    newText: ' '
+                });
+                continue;
+            }
+            // Rule 3: Replace multiple newlines with single space between tokens
+            // (newlines between keywords should become space)
+            // This is handled by checking for consecutive newlines
+            if ((text.includes('\n') || text.includes('\r')) && !text.includes('  ')) {
+                // Count newlines
+                const newlineCount = (text.match(/\n/g) || []).length + (text.match(/\r/g) || []).length;
+                if (newlineCount > 1) {
+                    // Multiple newlines - replace with single space
+                    this.editCollector.addEdit({
+                        range: {
+                            start: { line: startLine, character: startChar },
+                            end: { line: startLine, character: endChar }
+                        },
+                        newText: ' '
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Clean up extra spaces inside parentheses: ( a, b ) -> (a, b)
+     * Clean up comma spacing: a , b -> a, b
+     * Called after main formatting is done
+     */
+    cleanParenthesesSpaces() {
+        const allTokens = this.tokens.getTokens();
+        // Find all parentheses pairs and clean spaces inside
+        for (let i = 0; i < allTokens.length; i++) {
+            const token = allTokens[i];
+            // Check for left paren - ensure no space after
+            if (token.text === '(' && token.channel === 0) {
+                // Check if next token is whitespace with leading space
+                if (i + 1 < allTokens.length) {
+                    const nextToken = allTokens[i + 1];
+                    // Only process if next token is whitespace on same line
+                    if (nextToken.channel === 1 &&
+                        nextToken.text &&
+                        nextToken.text.includes(' ') &&
+                        nextToken.line === token.line) {
+                        // Check if this is IN ( or EXISTS ( - skip cleaning as it should be "IN (\n  SELECT"
+                        // Check if previous token is IN or EXISTS
+                        let skipCleaning = false;
+                        if (i > 0) {
+                            const prevToken = allTokens[i - 1];
+                            if (prevToken.channel === 0 &&
+                                (prevToken.text?.toUpperCase() === 'IN' || prevToken.text?.toUpperCase() === 'EXISTS')) {
+                                skipCleaning = true;
+                            }
+                        }
+                        if (!skipCleaning) {
+                            // Remove the space part after (
+                            const nextStartChar = nextToken.charPositionInLine;
+                            const nextEndChar = nextStartChar + nextToken.text.length;
+                            if (!this.editCollector.hasOverlappingEdit(nextToken.line - 1, nextStartChar, nextToken.line - 1, nextEndChar)) {
+                                // Keep only the non-space parts (like newlines)
+                                const nonSpacePart = nextToken.text.replace(/^ +/, '');
+                                this.editCollector.addEdit({
+                                    range: {
+                                        start: { line: nextToken.line - 1, character: nextStartChar },
+                                        end: { line: nextToken.line - 1, character: nextEndChar }
+                                    },
+                                    newText: nonSpacePart
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // Check for right paren - ensure no space before
+            if (token.text === ')' && token.channel === 0) {
+                // Check if previous token is whitespace with trailing space
+                if (i > 0) {
+                    const prevToken = allTokens[i - 1];
+                    // Only process if prev token is whitespace on same line
+                    if (prevToken.channel === 1 &&
+                        prevToken.text &&
+                        prevToken.text.includes(' ') &&
+                        prevToken.line === token.line) {
+                        // Remove the space part before )
+                        const prevStartChar = prevToken.charPositionInLine;
+                        const prevEndChar = prevStartChar + prevToken.text.length;
+                        if (!this.editCollector.hasOverlappingEdit(prevToken.line - 1, prevStartChar, prevToken.line - 1, prevEndChar)) {
+                            // Keep only the non-space parts (like newlines)
+                            const nonSpacePart = prevToken.text.replace(/ +$/, '');
+                            this.editCollector.addEdit({
+                                range: {
+                                    start: { line: prevToken.line - 1, character: prevStartChar },
+                                    end: { line: prevToken.line - 1, character: prevEndChar }
+                                },
+                                newText: nonSpacePart
+                            });
+                        }
+                    }
+                }
+            }
+            // Clean space before comma
+            if (token.text === ',' && token.channel === 0) {
+                // Check if previous token is whitespace with space
+                if (i > 0) {
+                    const prevToken = allTokens[i - 1];
+                    if (prevToken.channel === 1 &&
+                        prevToken.text &&
+                        prevToken.text.includes(' ') &&
+                        prevToken.line === token.line) {
+                        // Remove space before comma
+                        const prevStartChar = prevToken.charPositionInLine;
+                        const prevEndChar = prevStartChar + prevToken.text.length;
+                        if (!this.editCollector.hasOverlappingEdit(prevToken.line - 1, prevStartChar, prevToken.line - 1, prevEndChar)) {
+                            const nonSpacePart = prevToken.text.replace(/ +$/, '');
+                            this.editCollector.addEdit({
+                                range: {
+                                    start: { line: prevToken.line - 1, character: prevStartChar },
+                                    end: { line: prevToken.line - 1, character: prevEndChar }
+                                },
+                                newText: nonSpacePart
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    getJoinFormattingBridge() {
+        return {
+            updateAfterPreviousTokenByContext: (ctx, newText) => this.updateAfterPreviousTokenByContext(ctx, newText),
+            updateAfterPreviousTokenByNode: (node, newText) => this.updateAfterPreviousTokenByNode(node, newText),
+            updateBeforeNextTokenByNode: (node, newText) => this.updateBeforeNextTokenByNode(node, newText)
+        };
+    }
+    getPipeStepBridge() {
+        return {
+            visit: (ctx) => this.visit(ctx),
+            visitNode: (ctx) => this.visit(ctx),
+            visitChildren: (ctx) => super.visitChildren(ctx),
+            updateAfterPreviousTokenByContext: (ctx, newText) => this.updateAfterPreviousTokenByContext(ctx, newText),
+            updateBeforeNextTokenByContext: (ctx, newText) => this.updateBeforeNextTokenByContext(ctx, newText),
+            updateAfterPreviousTokenByNode: (node, newText) => this.updateAfterPreviousTokenByNode(node, newText),
+            updateBeforeNextTokenByNode: (node, newText) => this.updateBeforeNextTokenByNode(node, newText),
+            restorePipeFormattingState: (formatting) => {
+                this.inPipeOperatorRightSide = formatting.previousInPipeOperatorRightSide;
+            }
+        };
+    }
+    getPipeStepKind(ctx) {
+        if (ctx.selectClause())
+            return 'pipe.select';
+        if (ctx.whereClause())
+            return 'pipe.where';
+        if (ctx.SET())
+            return 'pipe.set';
+        if (ctx.DROP())
+            return 'pipe.drop';
+        if (ctx.EXTEND())
+            return 'pipe.extend';
+        if (ctx.joinRelation())
+            return 'pipe.join';
+        if (ctx.aggregationClause())
+            return 'pipe.aggregate';
+        if (ctx.queryOrganization())
+            return 'pipe.queryOrganization';
+        if (ctx.sample())
+            return 'pipe.sample';
+        if (ctx.pivotClause())
+            return 'pipe.pivot';
+        if (ctx.unpivotClause())
+            return 'pipe.unpivot';
+        return 'pipe.unknown';
+    }
+    // ==================== Compound Statement (Stored Procedures) ====================
+    visitSingleCompoundStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitBeginEndCompoundBlock(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCompoundBody(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCompoundStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitIfElseStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitWhileStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitLoopStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitRepeatStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitForStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitCaseStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitSearchedCaseStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitSimpleCaseStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitLeaveStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitIterateStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDeclareConditionStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+    visitDeclareHandlerStatement(ctx) {
+        if (!this.tryFormatWithStrategy(ctx)) {
+            super.visitChildren(ctx);
+        }
+    }
+}
+exports.StrategyBasedFormatter = StrategyBasedFormatter;
+//# sourceMappingURL=strategy-based-formatter.js.map