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

package/out-tsc/listeners/statement.listener.js

@@ -15,29 +15,854 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatementListener = void 0;
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+const antlr4ts_1 = require("antlr4ts");
 const lsp = __importStar(require("vscode-languageserver"));
+const SparkSQLLexer_1 = require("../lib/SparkSQLLexer");
+/**
+ * Internal level tags for filtering folding ranges
+ * These map to the public FoldingLevel type but are used internally
+ */
+var FoldingLevelTag;
+(function (FoldingLevelTag) {
+    FoldingLevelTag[FoldingLevelTag["Statement"] = 1] = "Statement";
+    FoldingLevelTag[FoldingLevelTag["Query"] = 2] = "Query";
+    FoldingLevelTag[FoldingLevelTag["Expression"] = 3] = "Expression";
+    FoldingLevelTag[FoldingLevelTag["Other"] = 4] = "Other"; // 其他 (comments, regions, JOIN blocks, column lists)
+})(FoldingLevelTag || (FoldingLevelTag = {}));
+/**
+ * StatementListener - 用于代码折叠的语句监听器
+ *
+ * 折叠范围（按照 SQL 代码编辑器常用折叠规范）：
+ *
+ * 1. Statement 级别（84种 DDL/DML/DQL 语句）- 逐一注册
+ * 2. Query 级别 - CTE、子查询
+ * 3. 复杂表达式级别 - CASE WHEN、窗口定义等
+ * 4. 注释级别 - 多行 block 注释
+ *
+ * 注意：单行语句不折叠，只对跨多行的代码块进行折叠。
+ */
 class StatementListener {
-    constructor(document) {
+    constructor(document, level = 'all', enableCTEChain = false) {
         this.document = document;
         this.ranges = [];
+        this.joinRelations = [];
+        this.cteDependencies = [];
+        this.allCTENames = new Set();
+        this.foldingLevel = level;
+        this.enableCTEDependencyChain = enableCTEChain;
     }
     getRanges() {
+        return this.ranges.map(r => r.range);
+    }
+    /**
+     * Get folding ranges with kind classification
+     */
+    getFoldingRanges() {
+        // Scan for block comments before returning
+        this.scanBlockComments();
+        // Process collected JOIN blocks
+        this.processJoinBlocks();
+        // Scan for #region/#endregion markers
+        this.scanRegionMarkers();
+        // Scan for consecutive -- comment blocks
+        this.scanLineComments();
+        // Process CTE dependency chains
+        if (this.enableCTEDependencyChain) {
+            this.processCTEDependencyChains();
+        }
+        // Optimize ranges (deduplication, parent-child optimization)
+        this.optimizeRanges();
         return this.ranges;
     }
-    enterStatementForFolding(ctx) {
+    /**
+     * 通用的 Range 计算逻辑
+     * 只保留跨多行的范围，单行没必要折叠
+     * 自动去重：相同起止行的范围只保留一个
+     * @param levelTag 内部级别标签，用于过滤
+     */
+    addRange(ctx, kind, levelTag = FoldingLevelTag.Statement) {
+        // 根据配置的级别过滤
+        if (!this.shouldIncludeRange(levelTag)) {
+            return;
+        }
         const startOffset = ctx.start.startIndex;
         const stopOffset = ctx.stop ? ctx.stop.stopIndex + 1 : startOffset + ctx.text.length;
-        const range = lsp.Range.create(this.document.positionAt(ctx.start.startIndex), this.document.positionAt(stopOffset));
-        this.ranges.push(range);
+        const range = lsp.Range.create(this.document.positionAt(startOffset), this.document.positionAt(stopOffset));
+        if (range.start.line < range.end.line) {
+            // 去重：相同起止行的范围只保留一个
+            const exists = this.ranges.some(r => r.range.start.line === range.start.line && r.range.end.line === range.end.line);
+            if (!exists) {
+                this.ranges.push({ range, kind, _levelTag: levelTag });
+            }
+        }
+    }
+    /**
+     * 判断是否应该包含该级别的折叠范围
+     */
+    shouldIncludeRange(levelTag) {
+        switch (this.foldingLevel) {
+            case 'statement':
+                return levelTag === FoldingLevelTag.Statement;
+            case 'query':
+                return levelTag <= FoldingLevelTag.Query;
+            case 'expression':
+                return levelTag <= FoldingLevelTag.Expression;
+            case 'all':
+            default:
+                return true;
+        }
+    }
+    /**
+     * 扫描多行 block 注释并生成折叠范围
+     * 只对跨行的注释生成 FoldingRange(kind=Comment)
+     *
+     * 注意：此方法在 getFoldingRanges() 中自动调用，
+     * 如果直接调用 getRanges() 则不会扫描注释（保持向后兼容）。
+     */
+    scanBlockComments() {
+        // 检查是否已经扫描过（避免重复扫描）
+        const text = this.document.getText();
+        const chars = antlr4ts_1.CharStreams.fromString(text);
+        const lexer = new SparkSQLLexer_1.SparkSQLLexer(chars);
+        const tokens = new antlr4ts_1.CommonTokenStream(lexer);
+        tokens.fill();
+        for (const token of tokens.getTokens()) {
+            // BRACKETED_COMMENT = /* */ 类型注释
+            if (token.type === SparkSQLLexer_1.SparkSQLLexer.BRACKETED_COMMENT) {
+                const startLine = token.line - 1; // ANTLR line 是 1-indexed
+                const stopLine = token.line - 1 + ((token.text?.split('\n').length || 1) - 1);
+                // 只折叠跨行的注释（≥2 行）
+                if (startLine < stopLine) {
+                    // 级别过滤：Other 级别只在 'all' 时包含
+                    if (!this.shouldIncludeRange(FoldingLevelTag.Other)) {
+                        continue;
+                    }
+                    const range = lsp.Range.create(this.document.positionAt(token.startIndex), this.document.positionAt(token.stopIndex + 1));
+                    this.ranges.push({
+                        range,
+                        kind: lsp.FoldingRangeKind.Comment,
+                        _levelTag: FoldingLevelTag.Other
+                    });
+                }
+            }
+        }
+    }
+    // ==================== Statement 包装 ====================
+    enterStatementForFolding(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DQL - 查询语句 ====================
+    enterStatementDefault(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDescribeQuery(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DML - 数据操作语句 ====================
+    enterDmlStatement(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DDL - Namespace ====================
+    enterCreateNamespace(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterSetNamespaceProperties(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterUnsetNamespaceProperties(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterSetNamespaceCollation(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterSetNamespaceLocation(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropNamespace(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DDL - Table ====================
+    enterCreateTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterCreateTableLike(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterReplaceTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAddTableColumns(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterRenameTableColumn(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropTableColumns(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterRenameTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterSetTableProperties(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterUnsetTableProperties(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAlterTableAlterColumn(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterHiveChangeColumn(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterHiveReplaceColumns(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterSetTableSerDe(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAddTablePartition(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterRenameTablePartition(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropTablePartitions(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterSetTableLocation(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterRecoverPartitions(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAlterClusterBy(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAlterTableCollation(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAddTableConstraint(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropTableConstraint(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterTruncateTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterRepairTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DDL - View ====================
+    enterCreateView(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterCreateMetricView(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterCreateTempViewUsing(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAlterViewQuery(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAlterViewSchemaBinding(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropView(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DDL - Function ====================
+    enterCreateFunction(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterCreateUserDefinedFunction(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropFunction(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DDL - Variable ====================
+    enterCreateVariable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropVariable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DDL - Index ====================
+    enterCreateIndex(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDropIndex(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DDL - Pipeline ====================
+    enterCreatePipelineDataset(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterCreatePipelineInsertIntoFlow(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== Session/Catalog 操作 ====================
+    enterUse(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterUseNamespace(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterSetCatalog(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== SHOW 语句 ====================
+    enterShowNamespaces(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowTables(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowTableExtended(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowTblProperties(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowColumns(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowViews(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowPartitions(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowFunctions(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowProcedures(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowCreateTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowCurrentNamespace(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterShowCatalogs(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== DESCRIBE 语句 ====================
+    enterDescribeFunction(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDescribeProcedure(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDescribeNamespace(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterDescribeRelation(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== ANALYZE 语句 ====================
+    enterAnalyze(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterAnalyzeTables(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== EXPLAIN 语句 ====================
+    enterExplain(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== COMMENT 语句 ====================
+    enterCommentNamespace(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterCommentTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== REFRESH 语句 ====================
+    enterRefreshTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterRefreshFunction(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterRefreshResource(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== CACHE 语句 ====================
+    enterCacheTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterUncacheTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterClearCache(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== 数据加载 ====================
+    enterLoadData(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== 资源管理 ====================
+    enterManageResource(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== 存储过程调用 ====================
+    enterCall(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== 其他 ====================
+    enterVisitExecuteImmediate(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    enterFailNativeCommand(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Statement);
+    }
+    // ==================== Query 相关 ====================
+    /**
+     * 监听 query（SELECT 查询，包括子查询、CTE 内部查询）
+     */
+    enterQuery(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Query);
+    }
+    /**
+     * 监听 WITH 子句整体（CTEs）
+     * 使用 kind=Imports 表示 CTE 定义块
+     */
+    enterCtes(ctx) {
+        this.addRange(ctx, lsp.FoldingRangeKind.Imports, FoldingLevelTag.Query);
+    }
+    /**
+     * 监听单个 CTE 定义（namedQuery）
+     * 使用 kind=Imports 表示 CTE 定义块
+     */
+    enterNamedQuery(ctx) {
+        // 收集 CTE 依赖信息
+        const cteName = ctx.errorCapturingIdentifier()?.text;
+        if (cteName) {
+            this.allCTENames.add(cteName);
+            // 使用 ctx.text 获取 CTE 文本
+            const cteText = ctx.text;
+            const deps = this.extractCTEDependencies(cteText);
+            this.cteDependencies.push({
+                name: cteName,
+                startLine: ctx.start.line - 1, // ANTLR line is 1-indexed
+                endLine: ctx.stop ? ctx.stop.line - 1 : ctx.start.line - 1,
+                dependencies: deps
+            });
+        }
+        this.addRange(ctx, lsp.FoldingRangeKind.Imports, FoldingLevelTag.Query);
+    }
+    /**
+     * 监听常规查询规范（SELECT ... FROM ... WHERE ...）
+     * 这是实际的 SELECT 查询块，包括主查询和 CTE 内部的查询
+     */
+    enterRegularQuerySpecification(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Query);
+    }
+    // ==================== 复杂表达式 ====================
+    /**
+     * 监听子查询表达式
+     */
+    enterSubqueryExpression(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Query);
+    }
+    /**
+     * 监听内联表 VALUES
+     */
+    enterInlineTable(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Query);
+    }
+    /**
+     * 监听集合操作 UNION/INTERSECT/EXCEPT
+     */
+    enterSetOperation(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Query);
+    }
+    /**
+     * 监听 Searched CASE 表达式
+     */
+    enterSearchedCase(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Expression);
+    }
+    /**
+     * 监听 Simple CASE 表达式
+     */
+    enterSimpleCase(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Expression);
+    }
+    /**
+     * 监听窗口定义
+     * 只对 ≥3 行的窗口定义生成折叠，避免过度折叠
+     */
+    enterWindowDef(ctx) {
+        // 阈值检查：≥3 行才折叠
+        if (ctx.stop && ctx.stop.line - ctx.start.line >= 2) {
+            this.addRange(ctx, undefined, FoldingLevelTag.Expression);
+        }
+    }
+    // ==================== 括号相关 ====================
+    /**
+     * 监听函数调用 function_name(arg1, arg2, ...)
+     * 只对 ≥3 行的函数调用生成折叠，避免过度折叠
+     */
+    enterFunctionCall(ctx) {
+        // 阈值检查：≥3 行才折叠（stop.line - start.line >= 2 表示至少跨越 3 行）
+        if (ctx.stop && ctx.stop.line - ctx.start.line >= 2) {
+            this.addRange(ctx, undefined, FoldingLevelTag.Expression);
+        }
+    }
+    /**
+     * 监听括号表达式 (expression)
+     * 只对 ≥3 行的括号表达式生成折叠，避免过度折叠
+     */
+    enterParenthesizedExpression(ctx) {
+        // 阈值检查：≥3 行才折叠（stop.line - start.line >= 2 表示至少跨越 3 行）
+        if (ctx.stop && ctx.stop.line - ctx.start.line >= 2) {
+            this.addRange(ctx, undefined, FoldingLevelTag.Expression);
+        }
+    }
+    /**
+     * 监听表元素列表 (col1 INT, col2 STRING, ...)
+     * 用于 CREATE TABLE 等 DDL 语句中的列定义
+     */
+    enterTableElementList(ctx) {
+        this.addRange(ctx, undefined, FoldingLevelTag.Expression);
+    }
+    // ==================== Phase 2: 超越 Databricks ====================
+    /**
+     * 收集 JOIN 关系节点（在 AST walk 中自动调用）
+     */
+    enterJoinRelation(ctx) {
+        this.joinRelations.push(ctx);
+    }
+    /**
+     * 处理收集到的 JOIN 关系，生成折叠范围
+     * 当 2+ 个连续 JOIN 时，折叠整个 JOIN 块
+     * 单个 JOIN 不单独折叠（包含在 SELECT 块折叠中）
+     */
+    processJoinBlocks() {
+        // 级别过滤：Other 级别只在 'all' 时包含
+        if (!this.shouldIncludeRange(FoldingLevelTag.Other)) {
+            return;
+        }
+        if (this.joinRelations.length < 2) {
+            return; // 少于 2 个 JOIN，不生成折叠
+        }
+        // 按起始位置排序
+        this.joinRelations.sort((a, b) => a.start.startIndex - b.start.startIndex);
+        // 查找连续的 JOIN 块
+        let blockStart = this.joinRelations[0];
+        let blockEnd = this.joinRelations[0];
+        for (let i = 1; i < this.joinRelations.length; i++) {
+            const current = this.joinRelations[i];
+            const prev = this.joinRelations[i - 1];
+            // 检查是否连续：gap 较小（允许注释和空格）
+            const prevStop = prev.stop ? prev.stop.stopIndex : prev.start.startIndex + prev.text.length;
+            const gap = current.start.startIndex - prevStop;
+            if (gap >= 0 && gap < 500) {
+                // 连续 JOIN，扩展块
+                blockEnd = current;
+            }
+            else {
+                // 不连续，输出前一个块
+                this.addJoinBlockRange(blockStart, blockEnd);
+                blockStart = current;
+                blockEnd = current;
+            }
+        }
+        // 输出最后一个块
+        this.addJoinBlockRange(blockStart, blockEnd);
+    }
+    /**
+     * 添加 JOIN 块折叠范围
+     */
+    addJoinBlockRange(start, end) {
+        const startOffset = start.start.startIndex;
+        const stopOffset = end.stop ? end.stop.stopIndex + 1 : start.start.startIndex + start.text.length;
+        const range = lsp.Range.create(this.document.positionAt(startOffset), this.document.positionAt(stopOffset));
+        // 只折叠跨多行的 JOIN 块
+        if (range.start.line < range.end.line) {
+            // 去重检查
+            const exists = this.ranges.some(r => r.range.start.line === range.start.line && r.range.end.line === range.end.line);
+            if (!exists) {
+                this.ranges.push({ range, _levelTag: FoldingLevelTag.Other });
+            }
+        }
+    }
+    /**
+     * 扫描 #region/#endregion 标记并生成折叠范围
+     * 支持嵌套 region，未配对的标记忽略
+     * 生成 FoldingRange(kind=Region)
+     */
+    scanRegionMarkers() {
+        // 级别过滤：Other 级别只在 'all' 时包含
+        if (!this.shouldIncludeRange(FoldingLevelTag.Other)) {
+            return;
+        }
+        const text = this.document.getText();
+        const lines = text.split('\n');
+        const stack = []; // region 起始行栈
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim().toLowerCase();
+            // 检测 #region
+            if (line.startsWith('-- #region') || line.startsWith('--#region')) {
+                stack.push(i);
+            }
+            // 检测 #endregion
+            if (line.startsWith('-- #endregion') || line.startsWith('--#endregion')) {
+                if (stack.length > 0) {
+                    const startLine = stack.pop();
+                    // 至少 3 行（至少 1 行内容）才折叠
+                    if (i - startLine > 1) {
+                        const range = lsp.Range.create(lsp.Position.create(startLine, 0), lsp.Position.create(i, lines[i].length));
+                        // 去重检查
+                        const exists = this.ranges.some(r => r.range.start.line === range.start.line && r.range.end.line === range.end.line);
+                        if (!exists) {
+                            this.ranges.push({
+                                range,
+                                kind: lsp.FoldingRangeKind.Region,
+                                _levelTag: FoldingLevelTag.Other
+                            });
+                        }
+                    }
+                }
+                // 未配对的 #endregion 忽略
+            }
+        }
+        // 未配对的 #region 忽略
+    }
+    /**
+     * 扫描连续多行 -- 注释并生成折叠范围
+     * 只对 3+ 行连续注释生成 FoldingRange(kind=Comment)
+     */
+    scanLineComments() {
+        // 级别过滤：Other 级别只在 'all' 时包含
+        if (!this.shouldIncludeRange(FoldingLevelTag.Other)) {
+            return;
+        }
+        const text = this.document.getText();
+        const lines = text.split('\n');
+        let blockStart = -1;
+        let blockEnd = -1;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            const isComment = line.startsWith('--') &&
+                !line.startsWith('-- #region') &&
+                !line.startsWith('--#region') &&
+                !line.startsWith('-- #endregion') &&
+                !line.startsWith('--#endregion');
+            if (isComment) {
+                if (blockStart === -1) {
+                    blockStart = i;
+                }
+                blockEnd = i;
+            }
+            else {
+                // 注释块结束
+                if (blockStart !== -1 && blockEnd - blockStart >= 2) {
+                    // 3+ 行注释块，生成折叠范围
+                    const range = lsp.Range.create(lsp.Position.create(blockStart, 0), lsp.Position.create(blockEnd, lines[blockEnd].length));
+                    this.ranges.push({
+                        range,
+                        kind: lsp.FoldingRangeKind.Comment,
+                        _levelTag: FoldingLevelTag.Other
+                    });
+                }
+                blockStart = -1;
+                blockEnd = -1;
+            }
+        }
+        // 处理文件末尾的注释块
+        if (blockStart !== -1 && blockEnd - blockStart >= 2) {
+            const range = lsp.Range.create(lsp.Position.create(blockStart, 0), lsp.Position.create(blockEnd, lines[blockEnd].length));
+            this.ranges.push({
+                range,
+                kind: lsp.FoldingRangeKind.Comment,
+                _levelTag: FoldingLevelTag.Other
+            });
+        }
+    }
+    /**
+     * 优化折叠范围
+     * 1. 去除相同起止行的重复范围
+     * 2. 优化父子范围关系（相同起止行保留子范围）
+     */
+    optimizeRanges() {
+        // 按起始行排序，然后按结束行降序
+        this.ranges.sort((a, b) => {
+            if (a.range.start.line !== b.range.start.line) {
+                return a.range.start.line - b.range.start.line;
+            }
+            return b.range.end.line - a.range.end.line;
+        });
+        // 去重：相同起止行只保留第一个
+        const optimized = [];
+        for (const current of this.ranges) {
+            const isDuplicate = optimized.some(existing => existing.range.start.line === current.range.start.line && existing.range.end.line === current.range.end.line);
+            if (!isDuplicate) {
+                optimized.push(current);
+            }
+        }
+        this.ranges = optimized;
+    }
+    // ==================== Phase 4: CTE 依赖链折叠 ====================
+    /**
+     * 从 CTE 文本中提取依赖的其他 CTE 名称
+     * 通过查找已知的 CTE 名称在文本中的出现来确定依赖关系
+     */
+    extractCTEDependencies(cteText) {
+        const deps = [];
+        const lowerText = cteText.toLowerCase();
+        for (const cteName of this.allCTENames) {
+            // 检查 CTE 名称是否在当前 CTE 的文本中
+            // 使用简单的字符串搜索，避免正则表达式特殊字符问题
+            const lowerCteName = cteName.toLowerCase();
+            const firstIndex = lowerText.indexOf(lowerCteName);
+            if (firstIndex === -1) {
+                continue;
+            }
+            // 检查是否出现多次（排除 CTE 自身定义处的出现）
+            const secondIndex = lowerText.indexOf(lowerCteName, firstIndex + lowerCteName.length);
+            if (secondIndex !== -1) {
+                deps.push(cteName);
+            }
+        }
+        return deps;
+    }
+    /**
+     * 处理 CTE 依赖链，生成整体折叠范围
+     * 当有多个 CTE 存在依赖关系时，生成覆盖整个 WITH 块的折叠
+     */
+    processCTEDependencyChains() {
+        if (this.cteDependencies.length < 2) {
+            return; // 少于 2 个 CTE，不处理
+        }
+        // 查找有依赖关系的 CTE
+        const ctesWithDeps = this.cteDependencies.filter(cte => cte.dependencies.length > 0);
+        if (ctesWithDeps.length < 1) {
+            return; // 没有依赖关系，不处理
+        }
+        // 计算整个 WITH 块的范围（从第一个 CTE 到最后一个 CTE）
+        const sorted = [...this.cteDependencies].sort((a, b) => a.startLine - b.startLine);
+        const startLine = sorted[0].startLine;
+        const endLine = sorted[sorted.length - 1].endLine;
+        // 只折叠跨多行的 WITH 块
+        if (startLine < endLine) {
+            const range = lsp.Range.create(lsp.Position.create(startLine, 0), lsp.Position.create(endLine, 0));
+            // 去重检查
+            const exists = this.ranges.some(r => r.range.start.line === range.start.line && r.range.end.line === range.end.line);
+            if (!exists) {
+                this.ranges.push({
+                    range,
+                    kind: lsp.FoldingRangeKind.Imports,
+                    _levelTag: FoldingLevelTag.Query
+                });
+            }
+        }
+    }
+    // ==================== Phase 4: 折叠统计 ====================
+    /**
+     * 获取折叠统计信息
+     */
+    getStatistics() {
+        const rangesByKind = {};
+        const rangesByLevel = {};
+        for (const info of this.ranges) {
+            const kindKey = info.kind || 'undefined';
+            rangesByKind[kindKey] = (rangesByKind[kindKey] || 0) + 1;
+            const levelKey = FoldingLevelTag[info._levelTag || FoldingLevelTag.Statement];
+            rangesByLevel[levelKey] = (rangesByLevel[levelKey] || 0) + 1;
+        }
+        const depthStats = this.calculateDepthStats();
+        const coverageRatio = this.calculateCoverageRatio();
+        return {
+            totalRanges: this.ranges.length,
+            rangesByKind,
+            rangesByLevel,
+            maxDepth: depthStats.maxDepth,
+            avgDepth: depthStats.avgDepth,
+            coverageRatio,
+            optimizedCount: 0,
+            computeTimeMs: 0
+        };
+    }
+    /**
+     * 计算嵌套深度统计
+     */
+    calculateDepthStats() {
+        if (this.ranges.length === 0) {
+            return { maxDepth: 0, avgDepth: 0 };
+        }
+        let maxDepth = 0;
+        let totalDepth = 0;
+        for (const info of this.ranges) {
+            let depth = 1;
+            for (const other of this.ranges) {
+                if (other === info)
+                    continue;
+                // Check if other contains this range
+                if (other.range.start.line <= info.range.start.line &&
+                    other.range.end.line >= info.range.end.line &&
+                    (other.range.start.line < info.range.start.line || other.range.end.line > info.range.end.line)) {
+                    depth++;
+                }
+            }
+            maxDepth = Math.max(maxDepth, depth);
+            totalDepth += depth;
+        }
+        return {
+            maxDepth,
+            avgDepth: totalDepth / this.ranges.length
+        };
+    }
+    /**
+     * 计算折叠覆盖率 (被折叠覆盖的行数 / 总行数)
+     */
+    calculateCoverageRatio() {
+        if (this.ranges.length === 0) {
+            return 0;
+        }
+        const totalLines = this.document.lineCount;
+        if (totalLines === 0) {
+            return 0;
+        }
+        const coveredLines = new Set();
+        for (const info of this.ranges) {
+            for (let line = info.range.start.line; line <= info.range.end.line; line++) {
+                coveredLines.add(line);
+            }
+        }
+        return coveredLines.size / totalLines;
     }
 }
 exports.StatementListener = StatementListener;