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

package/out-tsc/tests/lsp-server.test.js

@@ -0,0 +1,1525 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const strategy_based_formatter_1 = require("../formatter/strategy-based-formatter");
+const lsp_server_1 = require("../lsp-server");
+describe('LSPServer', () => {
+    let server;
+    beforeEach(() => {
+        server = new lsp_server_1.LSPServer();
+    });
+    describe('doValidation', () => {
+        it('should return no errors for valid SQL', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, 'SELECT * FROM users');
+            const errors = server.doValidation(doc);
+            (0, chai_1.expect)(errors.length).to.equal(0);
+        });
+        it('should return errors for invalid SQL', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, 'SELECTX * FROM users');
+            const errors = server.doValidation(doc);
+            (0, chai_1.expect)(errors.length).to.be.greaterThan(0);
+        });
+    });
+    describe('doCompletion', () => {
+        it('should return completion items', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, 'SELECT ');
+            const result = server.doCompletion(doc, { line: 0, character: 7 });
+            (0, chai_1.expect)(result.completionItems.length).to.be.greaterThan(0);
+        });
+    });
+    describe('parseStructure', () => {
+        it('should parse structure for SELECT query', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, 'SELECT a, b FROM table1 WHERE c > 1');
+            const result = server.parseStructure(doc);
+            (0, chai_1.expect)(result.nodes.length).to.be.greaterThan(0);
+        });
+        it('should parse structure for INSERT statement', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, 'INSERT INTO target_table SELECT * FROM source_table');
+            const result = server.parseStructure(doc);
+            (0, chai_1.expect)(result.nodes.length).to.be.greaterThan(0);
+        });
+    });
+    describe('getLineage', () => {
+        it('should get lineage for SELECT query', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, 'SELECT a, b FROM table1');
+            const lineage = server.getLineage(doc);
+            (0, chai_1.expect)(lineage.nodes.length).to.be.greaterThan(0);
+        });
+        it('should get lineage for CREATE VIEW statement', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, 'CREATE VIEW my_view AS SELECT a, b FROM table1');
+            const lineage = server.getLineage(doc);
+            (0, chai_1.expect)(lineage.nodes.length).to.be.greaterThan(0);
+        });
+    });
+    describe('collectTokens', () => {
+        it('should collect tokens from SQL', () => {
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, "SELECT name FROM users WHERE id = 'test'");
+            const tokens = server.collectTokens(doc);
+            (0, chai_1.expect)(tokens.semanticTokens.length).to.be.greaterThanOrEqual(0);
+        });
+    });
+    describe('doFoldingRanges', () => {
+        it('should fold WITH clause with multiple CTEs', () => {
+            // 使用简化的、确定有效的 Spark SQL
+            const sql = `WITH cte1 AS (
+    SELECT
+        id,
+        name
+    FROM t1
+),
+cte2 AS (
+    SELECT
+        id,
+        CASE
+            WHEN id > 100 THEN 1
+            ELSE 0
+        END AS flag
+    FROM cte1
+)
+SELECT * FROM cte2`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            const ranges = server.doFoldingRanges(doc);
+            // 应该有多个折叠范围，包括两个 CTE 内的 SELECT
+            (0, chai_1.expect)(ranges.length).to.be.greaterThan(5);
+            // 第一个 SELECT 在第 1-4 行
+            const firstSelectRange = ranges.find(r => r.startLine === 1 && r.endLine === 4);
+            (0, chai_1.expect)(firstSelectRange).to.not.be.undefined;
+            // 第二个 SELECT 在第 7-13 行
+            const secondSelectRange = ranges.find(r => r.startLine === 7 && r.endLine === 13);
+            (0, chai_1.expect)(secondSelectRange).to.not.be.undefined;
+        });
+        it('should fold main SELECT after WITH clause', () => {
+            const sql = `WITH user_metrics AS (
+  SELECT 
+    u.id,
+    u.name,
+    COUNT(o.order_id) AS order_count,
+    SUM(o.amount) AS total_amount
+  FROM users u
+  LEFT JOIN orders o ON u.id = o.user_id
+  GROUP BY u.id, u.name
+),
+user_segments AS (
+  SELECT 
+    id,
+    name,
+    order_count,
+    total_amount,
+    CASE 
+      WHEN total_amount >= 10000 THEN 'VIP'
+      WHEN total_amount >= 5000 THEN 'Gold'
+      WHEN total_amount >= 1000 THEN 'Silver'
+      ELSE 'Bronze'
+    END AS segment,
+    CASE 
+      WHEN order_count >= 20 THEN 'High Frequency'
+      WHEN order_count >= 10 THEN 'Medium Frequency'
+      ELSE 'Low Frequency'
+    END AS frequency_tier
+  FROM user_metrics
+)
+SELECT 
+  segment,
+  frequency_tier,
+  COUNT(*) AS user_count,
+  AVG(total_amount) AS avg_spending
+FROM user_segments
+GROUP BY segment, frequency_tier
+ORDER BY 
+  CASE segment
+    WHEN 'VIP' THEN 1
+    WHEN 'Gold' THEN 2
+    WHEN 'Silver' THEN 3
+    ELSE 4
+  END`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            // 先验证语法正确
+            const errors = server.doValidation(doc);
+            (0, chai_1.expect)(errors.length, 'SQL should have no syntax errors').to.equal(0);
+            const ranges = server.doFoldingRanges(doc);
+            // 主 SELECT 从第 29 行开始 (0-indexed)，到第 35 行结束（FROM user_segments 到 ORDER BY 之前）
+            // 实际上主 SELECT 块包含 SELECT, FROM, GROUP BY，到 ORDER BY 之前
+            const mainSelectRange = ranges.find(r => r.startLine === 29);
+            (0, chai_1.expect)(mainSelectRange, 'Main SELECT (starting at line 29) should have a folding range').to.not.be.undefined;
+            // 验证 ORDER BY 中的 CASE 也被折叠
+            const orderByCaseRange = ranges.find(r => r.startLine === 37);
+            (0, chai_1.expect)(orderByCaseRange, 'ORDER BY CASE should have a folding range').to.not.be.undefined;
+            // 验证 CTE 内部的 SELECT 也被折叠
+            // 第一个 CTE 的 SELECT 从第 1 行开始
+            const firstCteSelectRange = ranges.find(r => r.startLine === 1);
+            (0, chai_1.expect)(firstCteSelectRange, 'First CTE SELECT should have a folding range').to.not.be.undefined;
+            // 第二个 CTE 的 SELECT 从第 11 行开始
+            const secondCteSelectRange = ranges.find(r => r.startLine === 11);
+            (0, chai_1.expect)(secondCteSelectRange, 'Second CTE SELECT should have a folding range').to.not.be.undefined;
+        });
+        it('should fold CREATE TEMPORARY VIEW statements', () => {
+            // 测试大写语法
+            const sql = `CREATE TEMPORARY VIEW nt1 AS SELECT * FROM VALUES
+  ('one', 1),
+  ('two', 2),
+  ('three', 3)
+  AS nt1(k, v1)`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            const errors = server.doValidation(doc);
+            console.log('CREATE VIEW errors:', errors.length > 0 ? errors[0].message : 'none');
+            const ranges = server.doFoldingRanges(doc);
+            const lines = sql.split('\n');
+            console.log('CREATE VIEW folding ranges:');
+            ranges.forEach((r, i) => {
+                console.log(`  ${i}: lines ${r.startLine}-${r.endLine} (${lines[r.startLine]?.trim().substring(0, 40)}...)`);
+            });
+            // CREATE VIEW 应该能折叠
+            const viewRange = ranges.find(r => r.startLine === 0);
+            (0, chai_1.expect)(viewRange, 'CREATE VIEW should have a folding range').to.not.be.undefined;
+        });
+        it('should handle case sensitivity', () => {
+            // 测试小写 SELECT
+            const sql1 = 'select * from users';
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql1);
+            const errors1 = server.doValidation(doc1);
+            console.log('小写 select:', errors1.length > 0 ? 'ERROR' : 'OK');
+            (0, chai_1.expect)(errors1.length, '小写 select 应该无错误').to.equal(0);
+            // 测试小写 create view
+            const sql2 = 'create view v as select 1';
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql2);
+            const errors2 = server.doValidation(doc2);
+            console.log('小写 create view:', errors2.length > 0 ? 'ERROR' : 'OK');
+            (0, chai_1.expect)(errors2.length, '小写 create view 应该无错误').to.equal(0);
+            // 测试小写 create temporary view
+            const sql3 = `create temporary view nt1 as select * from values
+  ('one', 1),
+  ('two', 2)
+  as nt1(k, v1)`;
+            const doc3 = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql3);
+            const errors3 = server.doValidation(doc3);
+            console.log('小写 create temporary view:', errors3.length > 0 ? 'ERROR' : 'OK');
+            (0, chai_1.expect)(errors3.length, '小写 create temporary view 应该无错误').to.equal(0);
+        });
+        it('should fold lowercase CREATE TEMPORARY VIEW statements', () => {
+            const sql = `create temporary view nt1 as select * from values
+  ("one", 1),
+  ("two", 2),
+  ("three", 3)
+  as nt1(k, v1);
+
+create temporary view nt2 as select * from values
+  ("one", 1),
+  ("two", 22),
+  ("one", 5)
+  as nt2(k, v2)`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            const ranges = server.doFoldingRanges(doc);
+            const lines = sql.split('\n');
+            console.log('小写 CREATE VIEW 折叠范围:');
+            ranges.forEach((r, i) => {
+                console.log(`  ${i}: lines ${r.startLine}-${r.endLine} (${lines[r.startLine]?.trim().substring(0, 40)}...)`);
+            });
+            // 第一个 CREATE VIEW 应该能折叠
+            const firstViewRange = ranges.find(r => r.startLine === 0);
+            (0, chai_1.expect)(firstViewRange, '第一个小写 CREATE VIEW 应该有折叠范围').to.not.be.undefined;
+            // 第二个 CREATE VIEW 应该能折叠
+            const secondViewRange = ranges.find(r => r.startLine === 6);
+            (0, chai_1.expect)(secondViewRange, '第二个小写 CREATE VIEW 应该有折叠范围').to.not.be.undefined;
+        });
+    });
+    describe('doFormatting', () => {
+        it('should format SELECT query with proper indentation', () => {
+            // 格式混乱的 SQL
+            const sql = 'SELECT a,b,c FROM users WHERE id=1 AND name="test"';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            // 应该返回格式化的编辑
+            (0, chai_1.expect)(edits.length).to.be.greaterThan(0);
+        });
+        it('should format CTE with proper indentation', () => {
+            const sql = `WITH cte AS (SELECT id FROM t) SELECT * FROM cte`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            // 应该返回格式化的编辑
+            (0, chai_1.expect)(edits.length).to.be.greaterThan(0);
+        });
+        it('should format CREATE VIEW statement', () => {
+            const sql = 'CREATE VIEW v AS SELECT a,b FROM t';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            // 应该返回格式化的编辑
+            (0, chai_1.expect)(edits.length).to.be.greaterThan(0);
+        });
+        it('should not break folding functionality after formatting', () => {
+            const sql = `WITH cte1 AS (
+    SELECT id FROM t1
+),
+cte2 AS (
+    SELECT id FROM cte1
+)
+SELECT * FROM cte2`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            // 执行格式化
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            (0, chai_1.expect)(edits).to.be.an('array');
+            // 验证折叠仍然工作
+            const ranges = server.doFoldingRanges(doc);
+            (0, chai_1.expect)(ranges.length).to.be.greaterThan(0);
+        });
+        it('should not break completion functionality after formatting', () => {
+            const sql = 'SELECT ';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://test.sql', 'sql', 1, sql);
+            // 执行格式化
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            (0, chai_1.expect)(edits).to.be.an('array');
+            // 验证补全仍然工作
+            const result = server.doCompletion(doc, { line: 0, character: 7 });
+            (0, chai_1.expect)(result.completionItems.length).to.be.greaterThan(0);
+        });
+        // 辅助函数：应用 TextEdit 到文本
+        function applyTextEdits(text, edits) {
+            // 按照从后往前的顺序排序编辑（避免位置偏移问题）
+            const sortedEdits = [...edits].sort((a, b) => {
+                if (a.range.start.line !== b.range.start.line) {
+                    return b.range.start.line - a.range.start.line;
+                }
+                return b.range.start.character - a.range.start.character;
+            });
+            const lines = text.split('\n');
+            for (const edit of sortedEdits) {
+                const startLine = edit.range.start.line;
+                const endLine = edit.range.end.line;
+                const startChar = edit.range.start.character;
+                const endChar = edit.range.end.character;
+                if (startLine === endLine) {
+                    // 单行编辑
+                    lines[startLine] =
+                        lines[startLine].substring(0, startChar) + edit.newText + lines[startLine].substring(endChar);
+                }
+                else {
+                    // 多行编辑
+                    const before = lines[startLine].substring(0, startChar);
+                    const after = lines[endLine].substring(endChar);
+                    const newText = before + edit.newText + after;
+                    lines.splice(startLine, endLine - startLine + 1, ...newText.split('\n'));
+                }
+            }
+            return lines.join('\n');
+        }
+        it('should be idempotent - formatting twice produces same result (CREATE VIEW)', () => {
+            const sql = 'CREATE VIEW v AS SELECT a FROM t';
+            // 使用不同的 URI 避免缓存问题
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://test1.sql', 'sql', 1, sql);
+            // 第一次格式化
+            const edits1 = server.doFormatting(doc1, { tabSize: 2, insertSpaces: true });
+            console.log('CREATE VIEW 第一次编辑列表:');
+            edits1.forEach((edit, i) => {
+                console.log(`  ${i}: [${edit.range.start.line}:${edit.range.start.character} -> ${edit.range.end.line}:${edit.range.end.character}] = ${JSON.stringify(edit.newText)}`);
+            });
+            const formatted1 = applyTextEdits(sql, edits1);
+            console.log('第一次格式化结果:', JSON.stringify(formatted1));
+            // 第二次格式化 - 使用不同的 URI
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://test2.sql', 'sql', 1, formatted1);
+            const edits2 = server.doFormatting(doc2, { tabSize: 2, insertSpaces: true });
+            console.log('CREATE VIEW 第二次编辑列表:');
+            edits2.forEach((edit, i) => {
+                console.log(`  ${i}: [${edit.range.start.line}:${edit.range.start.character} -> ${edit.range.end.line}:${edit.range.end.character}] = ${JSON.stringify(edit.newText)}`);
+            });
+            const formatted2 = applyTextEdits(formatted1, edits2);
+            console.log('第二次格式化结果:', JSON.stringify(formatted2));
+            // 第三次格式化 - 使用不同的 URI
+            const doc3 = vscode_languageserver_textdocument_1.TextDocument.create('test://test3.sql', 'sql', 1, formatted2);
+            const edits3 = server.doFormatting(doc3, { tabSize: 2, insertSpaces: true });
+            const formatted3 = applyTextEdits(formatted2, edits3);
+            console.log('第三次格式化结果:', JSON.stringify(formatted3));
+            // 两次格式化的结果应该相同（幂等性）
+            (0, chai_1.expect)(formatted2, '格式化应该是幂等的').to.equal(formatted1);
+            (0, chai_1.expect)(formatted3, '格式化应该是幂等的').to.equal(formatted2);
+        });
+        it('should be idempotent - formatting twice produces same result (CTE)', () => {
+            const sql = 'WITH cte AS (SELECT id FROM t) SELECT * FROM cte';
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://cte1.sql', 'sql', 1, sql);
+            // 第一次格式化
+            const edits1 = server.doFormatting(doc1, { tabSize: 2, insertSpaces: true });
+            const formatted1 = applyTextEdits(sql, edits1);
+            console.log('CTE 第一次格式化结果:', JSON.stringify(formatted1));
+            // 第二次格式化 - 使用不同的 URI
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://cte2.sql', 'sql', 1, formatted1);
+            const edits2 = server.doFormatting(doc2, { tabSize: 2, insertSpaces: true });
+            const formatted2 = applyTextEdits(formatted1, edits2);
+            console.log('CTE 第二次格式化结果:', JSON.stringify(formatted2));
+            // 第三次格式化 - 使用不同的 URI
+            const doc3 = vscode_languageserver_textdocument_1.TextDocument.create('test://cte3.sql', 'sql', 1, formatted2);
+            const edits3 = server.doFormatting(doc3, { tabSize: 2, insertSpaces: true });
+            const formatted3 = applyTextEdits(formatted2, edits3);
+            console.log('CTE 第三次格式化结果:', JSON.stringify(formatted3));
+            // 格式化应该是幂等的
+            (0, chai_1.expect)(formatted2, '格式化应该是幂等的').to.equal(formatted1);
+            (0, chai_1.expect)(formatted3, '格式化应该是幂等的').to.equal(formatted2);
+        });
+        it('should be idempotent - formatting twice produces same result (AS alias)', () => {
+            const sql = 'SELECT a AS alias FROM t';
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://alias1.sql', 'sql', 1, sql);
+            // 第一次格式化
+            const edits1 = server.doFormatting(doc1, { tabSize: 2, insertSpaces: true });
+            const formatted1 = applyTextEdits(sql, edits1);
+            console.log('AS alias 第一次格式化结果:', JSON.stringify(formatted1));
+            // 第二次格式化 - 使用不同的 URI
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://alias2.sql', 'sql', 1, formatted1);
+            const edits2 = server.doFormatting(doc2, { tabSize: 2, insertSpaces: true });
+            const formatted2 = applyTextEdits(formatted1, edits2);
+            console.log('AS alias 第二次格式化结果:', JSON.stringify(formatted2));
+            // 格式化应该是幂等的
+            (0, chai_1.expect)(formatted2, '格式化应该是幂等的').to.equal(formatted1);
+        });
+        it('should format CREATE TABLE statement and be idempotent', () => {
+            const sql = `CREATE TABLE IF
+ NOT EXISTS
+  test_inner_variable (a string, b int) PARTITIONED BY (pt string)`;
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://create-table1.sql', 'sql', 1, sql);
+            // 先验证语法正确
+            const errors = server.doValidation(doc1);
+            (0, chai_1.expect)(errors.length, 'CREATE TABLE 语法应该正确').to.equal(0);
+            // 第一次格式化
+            const edits1 = server.doFormatting(doc1, { tabSize: 2, insertSpaces: true });
+            console.log('CREATE TABLE 第一次编辑数量:', edits1.length);
+            const formatted1 = applyTextEdits(sql, edits1);
+            console.log('CREATE TABLE 第一次格式化结果:', JSON.stringify(formatted1));
+            // 应该产生格式化编辑
+            (0, chai_1.expect)(edits1.length, 'CREATE TABLE 应该产生格式化编辑').to.be.greaterThan(0);
+            // 第二次格式化 - 验证幂等性
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://create-table2.sql', 'sql', 1, formatted1);
+            const edits2 = server.doFormatting(doc2, { tabSize: 2, insertSpaces: true });
+            const formatted2 = applyTextEdits(formatted1, edits2);
+            console.log('CREATE TABLE 第二次格式化结果:', JSON.stringify(formatted2));
+            // 格式化应该是幂等的
+            (0, chai_1.expect)(formatted2, 'CREATE TABLE 格式化应该是幂等的').to.equal(formatted1);
+        });
+        it('should format INSERT statement with VALUES indentation', () => {
+            const sql = `INSERT OVERWRITE test_inner_variable PARTITION (pt = '\${ ds }') VALUES ('abc', 1), ('def', 2)`;
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://insert1.sql', 'sql', 1, sql);
+            // 先验证语法正确
+            const errors = server.doValidation(doc1);
+            (0, chai_1.expect)(errors.length, 'INSERT 语法应该正确').to.equal(0);
+            // 第一次格式化
+            const edits1 = server.doFormatting(doc1, { tabSize: 2, insertSpaces: true });
+            const formatted1 = applyTextEdits(sql, edits1);
+            console.log('INSERT 第一次格式化结果:', JSON.stringify(formatted1));
+            // 应该产生格式化编辑
+            (0, chai_1.expect)(edits1.length, 'INSERT 应该产生格式化编辑').to.be.greaterThan(0);
+            // 验证 PARTITION 和 VALUES 有缩进
+            (0, chai_1.expect)(formatted1).to.include('PARTITION');
+            (0, chai_1.expect)(formatted1).to.include('VALUES');
+            // 第二次格式化 - 验证幂等性
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://insert2.sql', 'sql', 1, formatted1);
+            const edits2 = server.doFormatting(doc2, { tabSize: 2, insertSpaces: true });
+            const formatted2 = applyTextEdits(formatted1, edits2);
+            console.log('INSERT 第二次格式化结果:', JSON.stringify(formatted2));
+            // 格式化应该是幂等的
+            (0, chai_1.expect)(formatted2, 'INSERT 格式化应该是幂等的').to.equal(formatted1);
+        });
+        it('should remove extra newlines before semicolon', () => {
+            // SQL 语句分号前有多个换行符
+            const sql = `SELECT * FROM t
+
+
+;`;
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://semicolon1.sql', 'sql', 1, sql);
+            // 先验证语法正确
+            const errors = server.doValidation(doc1);
+            console.log('分号测试验证结果:', errors.length > 0 ? errors[0].message : '无错误');
+            // 第一次格式化
+            const edits1 = server.doFormatting(doc1, { tabSize: 2, insertSpaces: true });
+            const formatted1 = applyTextEdits(sql, edits1);
+            console.log('分号测试第一次格式化结果:', JSON.stringify(formatted1));
+            // 格式化后分号前不应该有多余的换行符
+            (0, chai_1.expect)(formatted1).to.not.match(/\n\s*\n\s*;/);
+            // 第二次格式化 - 验证幂等性
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://semicolon2.sql', 'sql', 1, formatted1);
+            const edits2 = server.doFormatting(doc2, { tabSize: 2, insertSpaces: true });
+            const formatted2 = applyTextEdits(formatted1, edits2);
+            console.log('分号测试第二次格式化结果:', JSON.stringify(formatted2));
+            // 格式化应该是幂等的
+            (0, chai_1.expect)(formatted2, '格式化应该是幂等的').to.equal(formatted1);
+        });
+        it('should handle multiple newlines before column definitions', () => {
+            // 列定义前有多个换行符
+            const sql = `CREATE TABLE test
+
+
+(a string, b int)`;
+            const doc1 = vscode_languageserver_textdocument_1.TextDocument.create('test://newlines1.sql', 'sql', 1, sql);
+            // 先验证语法正确
+            const errors = server.doValidation(doc1);
+            console.log('列定义换行测试验证结果:', errors.length > 0 ? errors[0].message : '无错误');
+            // 第一次格式化
+            const edits1 = server.doFormatting(doc1, { tabSize: 2, insertSpaces: true });
+            console.log('列定义换行测试编辑数量:', edits1.length);
+            edits1.forEach((edit, i) => {
+                console.log(`  ${i}: [${edit.range.start.line}:${edit.range.start.character} -> ${edit.range.end.line}:${edit.range.end.character}] = ${JSON.stringify(edit.newText)}`);
+            });
+            const formatted1 = applyTextEdits(sql, edits1);
+            console.log('列定义换行测试第一次格式化结果:', JSON.stringify(formatted1));
+            // 应该产生格式化编辑，移除多余的换行
+            (0, chai_1.expect)(edits1.length, '应该产生格式化编辑').to.be.greaterThan(0);
+            // 格式化后不应该有多余的空行
+            (0, chai_1.expect)(formatted1).to.not.match(/CREATE TABLE test\n\n+\(/);
+            // 第二次格式化 - 验证幂等性
+            const doc2 = vscode_languageserver_textdocument_1.TextDocument.create('test://newlines2.sql', 'sql', 1, formatted1);
+            const edits2 = server.doFormatting(doc2, { tabSize: 2, insertSpaces: true });
+            const formatted2 = applyTextEdits(formatted1, edits2);
+            console.log('列定义换行测试第二次格式化结果:', JSON.stringify(formatted2));
+            // 格式化应该是幂等的
+            (0, chai_1.expect)(formatted2, '格式化应该是幂等的').to.equal(formatted1);
+        });
+        it('should format complex SQL with ROW_NUMBER correctly', () => {
+            const sql = `CREATE TEMPORARY VIEW dim_pub_uni_pruchase_item_tmp
+AS SELECT
+    app_id
+    ,item_id
+    ,item_type
+    ,product_price
+    ,update_time
+FROM (
+    SELECT
+    b.app_id
+    ,a.item_id
+    ,a.item_type
+    ,CAST(CAST(a.price AS DECIMAL(18, 2)) / 100 AS DECIMAL(18, 2)) AS product_price
+    ,a.update_time
+    ,ROW_NUMBER(
+    
+        ) OVER (
+            PARTITION BY b.app_id, a.item_id
+            ORDER BY a.update_time DESC) AS rn
+FROM nd_game_pub_cdm.dim_pub_uni_pruchase_item a
+    INNER JOIN nd_game_pub_cdm.dim_pub_uni_app_info_item_ref b
+        ON a.id = b.purchase_item_id
+) t
+WHERE rn = 1;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://complex.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            // ROW_NUMBER should not corrupt PARTITION
+            (0, chai_1.expect)(formatted).to.include('PARTITION BY');
+            // ROW_NUMBER() should be on one line (not split)
+            (0, chai_1.expect)(formatted).to.include('ROW_NUMBER()');
+            // Trailing comma style
+            (0, chai_1.expect)(formatted).to.include('app_id,');
+        });
+        it('should format pipe operator SELECT correctly', () => {
+            // Based on pipe.sql example
+            const sql = 'from t |> select x';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-select.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('Pipe SELECT 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果
+            // from 后面缩进2空格
+            (0, chai_1.expect)(formatted).to.include('from\n  t');
+            // |> select 在同一行
+            (0, chai_1.expect)(formatted).to.include('\n|> select');
+        });
+        it('should format chained pipe operators correctly', () => {
+            // Based on pipe.sql example (lines 22-31)
+            const sql = `from t as t_alias |> select t_alias.x as tx, t_alias.y as ty |> where ty = 'def' |> select tx`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-chained.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('Chained pipe 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('from\n  t as t_alias');
+            (0, chai_1.expect)(formatted).to.include('|> select');
+            (0, chai_1.expect)(formatted).to.include('where');
+        });
+        it('should format pipe SELECT with subquery expression correctly', () => {
+            // Based on pipe.sql example (lines 150-161)
+            const sql = 'table t |> select (select a from other where x = a limit 1) as result';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-subquery.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('子查询格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('table t');
+            (0, chai_1.expect)(formatted).to.include('|> select');
+            (0, chai_1.expect)(formatted).to.include('as result');
+        });
+        it('should format pipe with LATERAL VIEW correctly', () => {
+            // Based on pipe.sql example (lines 48-53)
+            const sql = 'from t lateral view explode(array(100, 101)) as ly |> select t.x + ly as z';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-lateral-view.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('LATERAL VIEW 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('from\n  t');
+            (0, chai_1.expect)(formatted).to.include('lateral view');
+            (0, chai_1.expect)(formatted).to.include('|> select');
+        });
+        it('should format pipe with LATERAL VIEW containing newlines', () => {
+            // Test case where input already has newlines between lateral and view
+            const sql = `from
+  t
+  lateral
+view
+   explode(array(100, 101)) as ly
+|> select
+     t.x + ly as z;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-lateral-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('LATERAL VIEW (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('lateral view');
+            (0, chai_1.expect)(formatted).to.include('|> select');
+        });
+        it('should format LATERAL VIEW with AS alias on same line', () => {
+            // Test case where AS alias has newline before it
+            const sql = `from
+  t
+lateral view explode(array(100, 101))
+ as ly
+|> select
+     t.x + ly as z;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-lateral-as.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('LATERAL VIEW AS 别名格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('lateral view');
+            (0, chai_1.expect)(formatted).to.include('as ly');
+        });
+        it('should format pipe SELECT with OVER clause correctly', () => {
+            // Based on pipe.sql example (lines 196-206)
+            const sql = 'select 1 x, 2 y, 3 z |> select 1 + sum(x) over (), avg(y) over (), x, avg(x + 1) over (partition by y order by z) AS a2 |> select a2';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-over.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('OVER 子句格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('|> select');
+            (0, chai_1.expect)(formatted).to.include('over ()');
+        });
+        it('should format pipe SELECT with OVER clause containing newlines', () => {
+            // Test case where input already has newlines inside OVER parentheses
+            const sql = `select
+  1 x
+|> select
+     sum(x) over (
+  ),
+     avg(x + 1) over (
+    partition by y
+    order by z
+  ) AS a2`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-over-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('OVER 子句 (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('|> select');
+        });
+        it('should format pipe EXTEND operator correctly', () => {
+            const sql = 'table t |> extend x + length(y) as z';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-extend.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('EXTEND 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('|> extend');
+        });
+        it('should format pipe SET operator correctly', () => {
+            const sql = 'table t |> set x = 1';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-set.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SET 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('|> set');
+        });
+        it('should format pipe SET with multiple expressions correctly', () => {
+            const sql = 'table t |> set x = 1, y = 2';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-set-multi.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SET 多表达式格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('|> set');
+        });
+        it('should format pipe DROP operator correctly', () => {
+            const sql = 'table t |> drop y';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-drop.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('DROP 格式化结果:');
+            console.log(formatted);
+            (0, chai_1.expect)(formatted).to.include('|> drop');
+        });
+        it('should format pipe AS operator correctly', () => {
+            const sql = 'table t |> as u |> select u.x';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-as.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('AS 格式化结果:');
+            console.log(formatted);
+            // AS alias stays on same line as |>
+            (0, chai_1.expect)(formatted).to.include('|> as u');
+        });
+        it('should format pipe AGGREGATE with GROUP BY correctly', () => {
+            const sql = 'table other |> aggregate sum(b) as result group by a';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-aggregate.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('AGGREGATE 格式化结果:');
+            console.log(formatted);
+            // GROUP BY should align with |> (indented)
+            (0, chai_1.expect)(formatted).to.include('|> aggregate');
+            (0, chai_1.expect)(formatted).to.include('group by');
+        });
+        it('should format pipe JOIN operator correctly', () => {
+            const sql = 'table t |> inner join other';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-join.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('JOIN 格式化结果:');
+            console.log(formatted);
+            // JOIN stays on same line as pipe operator
+            (0, chai_1.expect)(formatted).to.include('table t');
+            (0, chai_1.expect)(formatted).to.include('|> inner join');
+        });
+        it('should format pipe UNION operator correctly', () => {
+            const sql = 'table t |> union all table t';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-union.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('UNION 格式化结果:');
+            console.log(formatted);
+            // UNION ALL stays on same line as pipe operator
+            (0, chai_1.expect)(formatted).to.include('table t');
+            (0, chai_1.expect)(formatted).to.include('|> union all');
+        });
+        it('should format pipe ORDER BY operator correctly', () => {
+            const sql = 'table t |> order by x';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-orderby.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('ORDER BY 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('table t');
+            (0, chai_1.expect)(formatted).to.include('order by');
+        });
+        it('should format pipe LIMIT operator correctly', () => {
+            const sql = 'table t |> limit 1';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-limit.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('LIMIT 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('table t');
+            (0, chai_1.expect)(formatted).to.include('limit');
+        });
+        it('should format pipe TABLE with newlines in input', () => {
+            // Test case where input has newlines between TABLE and table name
+            const sql = `table
+t
+|> select
+     x + length(x) as z,
+     z + 1 as plus_one;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-table-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('TABLE (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // Should clean up newlines between TABLE and table name
+            const _expected = `table t
+|> select
+     x + length(x) as z,
+     z + 1 as plus_one;`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe SELECT DISTINCT correctly', () => {
+            // SELECT DISTINCT should have DISTINCT on same line as SELECT
+            const sql = 'table t |> select distinct x, y';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-select-distinct.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SELECT DISTINCT 格式化结果:');
+            console.log(formatted);
+            // DISTINCT should be on same line as SELECT
+            const _expected = `table t
+|> select distinct
+     x,
+     y`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe SELECT DISTINCT with newlines in input', () => {
+            // Test case where input has newlines between SELECT and DISTINCT
+            const sql = `table t
+|> select
+distinct x,
+     y;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-select-distinct-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SELECT DISTINCT (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // Should clean up newlines, DISTINCT stays on same line as SELECT
+            const _expected = `table t
+|> select distinct
+     x,
+     y;`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe SELECT with EXCEPT clause correctly', () => {
+            // SELECT * EXCEPT (y) should be on same line
+            const sql = 'table t |> select * except (y)';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-select-except.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SELECT EXCEPT 格式化结果:');
+            console.log(formatted);
+            // * except (y) should stay on same line
+            const _expected = `table t
+|> select
+     * except (y)`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe SELECT with EXCEPT clause and newlines in input', () => {
+            // Test case where input has newlines between * and except
+            const sql = `table t
+|> select
+     *
+      except
+      (y);`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-select-except-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SELECT EXCEPT (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // Should clean up newlines, * except (y) stays on same line
+            const _expected = `table t
+|> select
+     * except (y);`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe WHERE with EXISTS subquery correctly', () => {
+            const sql = 'table t |> where exists (select a from other where x = a limit 1)';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-where-exists.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('WHERE EXISTS 格式化结果:');
+            console.log(formatted);
+            // EXISTS should be on same line as WHERE
+            const _expected = `table t
+|> where
+     exists (
+       select
+         a
+       from
+         other
+       where
+         x = a
+       limit 1
+     )`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe WHERE with EXISTS subquery and newlines in input', () => {
+            // Test case where input has newlines between WHERE and EXISTS
+            const sql = `table t
+|> where
+     exists (
+  select
+        a
+  from
+    other
+      where
+        x = a
+  limit 1
+);`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-where-exists-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('WHERE EXISTS (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // Should clean up newlines between WHERE and EXISTS, keep EXISTS on same indent
+            const _expected = `table t
+|> where
+     exists (
+       select
+         a
+       from
+         other
+       where
+         x = a
+       limit 1
+     );`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe EXTEND with subquery correctly', () => {
+            const sql = 'table t |> extend (select a from other where x = a limit 1) as z';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-extend-subquery.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('EXTEND 子查询 格式化结果:');
+            console.log(formatted);
+            const _expected = `table t
+|> extend
+     (
+       select
+         a
+       from
+         other
+       where
+         x = a
+       limit 1
+     ) as z`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe EXTEND with subquery containing newlines', () => {
+            const sql = `table t
+|> extend
+     (
+       select
+         a
+       from
+         other
+       where
+         x = a
+       limit 1
+       ) as z;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-extend-subquery-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('EXTEND 子查询 (含换行输入) 格式化结果:');
+            console.log(formatted);
+            const _expected = `table t
+|> extend
+     (
+       select
+         a
+       from
+         other
+       where
+         x = a
+       limit 1
+     ) as z;`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe WHERE EXISTS with nested pipe operators', () => {
+            // EXISTS subquery containing pipe operators
+            const sql = `table t
+|> where
+     exists (
+       table other
+|> extend t.x
+|> select * except (a, b)
+     );`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-where-exists-pipe.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('WHERE EXISTS 嵌套管道 格式化结果:');
+            console.log(formatted);
+            // Pipe operators inside EXISTS should be indented relative to EXISTS
+            // EXTEND content stays on same line for simple expressions
+            // SELECT content goes on new line with 12-space indent (7 + 5)
+            const _expected = `table t
+|> where
+     exists (
+       table other
+       |> extend
+            t.x
+       |> select
+            * except (a, b)
+     );`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe JOIN with USING clause correctly', () => {
+            const sql = 'values (0), (1) lhs(a) |> inner join values (1), (2) rhs(a) using (a) |> select *';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-join-using.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('JOIN USING 格式化结果:');
+            console.log(formatted);
+            // USING should stay on same line as JOIN (compact mode)
+            (0, chai_1.expect)(formatted).to.include('inner join');
+            (0, chai_1.expect)(formatted).to.include('using (a)');
+        });
+        it('should format pipe WHERE with OR conditions correctly', () => {
+            const sql = "table t |> where y = 'abc' or length(y) + sum(x) = 1";
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-where-or.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('WHERE OR 格式化结果:');
+            console.log(formatted);
+            // OR should align with first condition (5-space indent)
+            const _expected = `table t
+|> where
+     y = 'abc'
+     or length(y) + sum(x) = 1`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format pipe WHERE with OR conditions and newlines in input', () => {
+            const sql = `table t
+|> where
+     y = 'abc'
+or length(y) + sum(x) = 1;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-where-or-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('WHERE OR (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // OR should align with first condition, clear extra newlines
+            const _expected = `table t
+|> where
+     y = 'abc'
+     or length(y) + sum(x) = 1;`;
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format complex pipe chain with USING and SET correctly', () => {
+            const sql = `values (0), (1) lhs(a)
+|> inner join values (1), (2) rhs(a)
+          using (a)
+|> extend
+     lhs.a + rhs.a as z1
+|> extend
+     lhs.a - rhs.a as z2
+|> drop
+     z1
+|> where
+     z2 = 0
+|> order by
+     lhs.a,
+     rhs.a,
+     z2
+|> set
+     z2 = 4
+|> limit 2
+|> select
+     lhs.a,
+     rhs.a,
+     z2;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-complex-chain.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('复杂管道链格式化结果:');
+            console.log(formatted);
+            // USING should be compact (same line as JOIN)
+            (0, chai_1.expect)(formatted).to.include('inner join');
+            // SET should be compact (same line)
+            (0, chai_1.expect)(formatted).to.include('set');
+            // EXTEND should have proper indent
+            (0, chai_1.expect)(formatted).to.include('extend');
+        });
+        // ==================== Standard JOIN Formatting Tests ====================
+        // Tests for docs/join-format-spec.md
+        // NOTE: These tests use StrategyBasedFormatter directly
+        it('should format INNER JOIN with ON correctly (strategy)', () => {
+            const sql = 'SELECT * FROM t1 INNER JOIN t2 ON t1.id = t2.id;';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://inner-join.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('INNER JOIN 格式化结果:');
+            console.log(formatted);
+            // JOIN on new line with 4 spaces indent, ON on new line with 6 spaces indent
+            (0, chai_1.expect)(formatted).to.include('  t1');
+            (0, chai_1.expect)(formatted).to.include('    INNER JOIN t2');
+            (0, chai_1.expect)(formatted).to.include('      ON t1.id = t2.id');
+        });
+        it('should format CROSS JOIN without ON correctly (strategy)', () => {
+            const sql = 'SELECT * FROM t1 CROSS JOIN t2;';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://cross-join.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('CROSS JOIN 格式化结果:');
+            console.log(formatted);
+            // No ON, so JOIN stays on same line as table (Rule 6)
+            (0, chai_1.expect)(formatted).to.include('  t1 CROSS JOIN t2');
+        });
+        it('should format NATURAL JOIN correctly (strategy)', () => {
+            const sql = 'SELECT * FROM t1 NATURAL JOIN t2;';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://natural-join.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('NATURAL JOIN 格式化结果:');
+            console.log(formatted);
+            // No ON, so JOIN stays on same line as table (Rule 6)
+            (0, chai_1.expect)(formatted).to.include('  t1 NATURAL JOIN t2');
+        });
+        it('should format JOIN with USING correctly (strategy)', () => {
+            const sql = 'SELECT * FROM t1 JOIN t2 USING (id);';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://join-using.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('JOIN USING 格式化结果:');
+            console.log(formatted);
+            // USING, no ON, so stays on same line (Rule 6)
+            (0, chai_1.expect)(formatted).to.include('  t1 JOIN t2 USING (id)');
+        });
+        it('should format LEFT OUTER JOIN correctly (strategy)', () => {
+            const sql = 'SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.id;';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://left-outer-join.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('LEFT OUTER JOIN 格式化结果:');
+            console.log(formatted);
+            (0, chai_1.expect)(formatted).to.include('  t1');
+            (0, chai_1.expect)(formatted).to.include('    LEFT OUTER JOIN t2');
+            (0, chai_1.expect)(formatted).to.include('      ON t1.id = t2.id');
+        });
+        it('should format multiple JOINs correctly (strategy)', () => {
+            const sql = 'SELECT * FROM t1 INNER JOIN t2 ON t1.id = t2.id INNER JOIN t3 ON t2.id = t3.id;';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://multi-join.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('Multiple JOIN 格式化结果:');
+            console.log(formatted);
+            (0, chai_1.expect)(formatted).to.include('  t1');
+            (0, chai_1.expect)(formatted).to.include('    INNER JOIN t2');
+            (0, chai_1.expect)(formatted).to.include('      ON t1.id = t2.id');
+            (0, chai_1.expect)(formatted).to.include('    INNER JOIN t3');
+            (0, chai_1.expect)(formatted).to.include('      ON t2.id = t3.id');
+        });
+        it('should format CREATE VIEW AS VALUES correctly (strategy)', () => {
+            const sql = 'CREATE TEMPORARY VIEW v1 AS VALUES (1, 1, 1), (2, 2, 1) AS t(a, b, k);';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://create-view-values.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('CREATE VIEW AS VALUES 格式化结果:');
+            console.log(formatted);
+            // Rule 1: AS 后换行，VALUES 在新行开始
+            (0, chai_1.expect)(formatted).to.include('CREATE TEMPORARY VIEW v1 AS\nVALUES');
+            // Rule 2: VALUES ... AS 不换行
+            (0, chai_1.expect)(formatted).to.include('VALUES (1, 1, 1), (2, 2, 1) AS t(a, b, k)');
+        });
+        it('should format CREATE VIEW AS VALUES with table alias correctly (strategy)', () => {
+            const sql = 'create temporary view nt1 as values ("one", 1), ("two", 2), ("three", 3) as nt1(k, v1);';
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://create-view-values2.sql', 'sql', 1, sql);
+            const parsingValue = server['_warehouse'].getParsingValue(doc);
+            const formatter = new strategy_based_formatter_1.StrategyBasedFormatter(parsingValue.tokenStream, { tabSize: 2, insertSpaces: true });
+            const edits = formatter.format(parsingValue.tree);
+            const formatted = applyTextEdits(sql, edits);
+            console.log('CREATE VIEW AS VALUES with alias 格式化结果:');
+            console.log(formatted);
+            // Rule 1: AS 后换行，VALUES 在新行开始
+            (0, chai_1.expect)(formatted.toLowerCase()).to.include('create temporary view nt1 as\nvalues');
+            // Rule 2: VALUES ... AS 不换行
+            (0, chai_1.expect)(formatted.toLowerCase()).to.include('values ("one", 1), ("two", 2), ("three", 3) as nt1(k, v1)');
+        });
+        it('should format pipe WHERE with WINDOW clause correctly', () => {
+            const sql = `table t
+|> where
+     sum(x) over w = 1
+window w as (
+  partition by y
+);`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-where-window.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('WHERE WINDOW 格式化结果:');
+            console.log(formatted);
+            // WINDOW should align with pipe operator (3 spaces indent), not with WHERE conditions (5 spaces)
+            (0, chai_1.expect)(formatted).to.include('window w as');
+        });
+        it('should format pipe PIVOT with single aggregation correctly', () => {
+            const sql = `table courseSales
+|> select
+     \`year\`,
+     course,
+     earnings
+|> pivot (
+  sum(earnings) for course in ('Java'));`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-pivot-single.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('PIVOT 单聚合格式化结果:');
+            console.log(formatted);
+            // Single aggregation: compact format
+            (0, chai_1.expect)(formatted).to.include("|> pivot (sum(earnings) for course in ('Java'))");
+        });
+        it('should format pipe PIVOT with multiple aggregations correctly', () => {
+            const sql = `table courseSales
+|> select
+     \`year\` as y,
+     course as c,
+     earnings as e
+|> pivot (
+  sum(e) as s, avg(e) as a for y in (2012 as firstYear, 2013 as secondYear));`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-pivot-multi.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('PIVOT 多聚合格式化结果:');
+            console.log(formatted);
+            // Multiple aggregations: newline format
+            (0, chai_1.expect)(formatted).to.include('pivot');
+        });
+        it('should format pipe SET with OVER expression correctly', () => {
+            const sql = `table t
+|> extend
+     1 as z
+|> set z= first_value(x) over (
+       partition by y
+     );`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-set-over.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SET OVER 格式化结果:');
+            console.log(formatted);
+            // SET with single expression should be compact and handle internal formatting
+            (0, chai_1.expect)(formatted).to.include('|> set');
+        });
+        it('should format pipe WHERE WINDOW clearing extra newlines correctly', () => {
+            const sql = `table t
+|> where
+     sum(x) over w = 1
+   window
+    
+    
+    w as (partition by y);`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-where-window-newlines.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('WHERE WINDOW 清理换行格式化结果:');
+            console.log(formatted);
+            // Extra newlines should be cleared, window should stay on one line
+            (0, chai_1.expect)(formatted).to.include('window w as');
+        });
+        it('should format pipe LIMIT OFFSET correctly', () => {
+            const sql = `table t
+|> select
+     x,
+     length(y) as z
+|> limit 1000
+ offset 1
+|> where
+     x + length(y) < 4;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-limit-offset.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('LIMIT OFFSET 格式化结果:');
+            console.log(formatted);
+            // OFFSET should stay on same line as LIMIT
+            (0, chai_1.expect)(formatted).to.include('limit');
+        });
+        it('should format pipe SELECT inside subquery with correct indent', () => {
+            const sql = `select
+  (
+    values (0) tab(col)
+    |> select
+     col
+  ) as result;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://pipe-select-subquery.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('子查询中管道 SELECT 格式化结果:');
+            console.log(formatted);
+            // col should be indented relative to select (9 spaces from line start)
+            (0, chai_1.expect)(formatted).to.include('|> select');
+        });
+        it('should clear newlines inside function arguments for compact mode', () => {
+            const sql = `table t
+|> select
+     (
+       select
+         any_value(
+
+          a)
+       from
+         other
+       where
+         x = a
+       limit 1
+     ) as result;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://function-compact-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('函数紧凑模式换行清理结果:');
+            console.log(formatted);
+            // any_value argument should be compact without newlines
+            (0, chai_1.expect)(formatted).to.include('any_value(a)');
+        });
+        it('should format listagg collate CTE case with stable multiline layout', () => {
+            const sql = `WITH t(c1) AS (SELECT replace(listagg(DISTINCT col1 COLLATE unicode_rtrim) COLLATE utf8_binary, ' ', '') FROM (VALUES ('xbc  '), ('xbc '), ('a'), ('xbc'))) SELECT len(c1), regexp_count(c1, 'a'), regexp_count(c1, 'xbc') FROM t;`;
+            const _expected = `WITH t(c1) AS (
+  SELECT
+    replace(listagg(DISTINCT col1 COLLATE unicode_rtrim) COLLATE utf8_binary, ' ', '')
+  FROM
+    (
+      VALUES ('xbc  '), ('xbc '), ('a'), ('xbc')
+    )
+)
+SELECT
+  len(c1),
+  regexp_count(c1, 'a'),
+  regexp_count(c1, 'xbc')
+FROM
+  t;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://listagg-collate-cte.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format listagg L6 case with multiline within group order by', () => {
+            const sql = `WITH t(c1) AS (SELECT listagg(col1) WITHIN GROUP (ORDER BY col1 COLLATE unicode_rtrim) FROM (VALUES ('abc '), ('abc\\n'), ('abc'), ('x'))) SELECT replace(replace(c1, ' ', ''), '\\n', '$') FROM t;`;
+            const _expected = `WITH t(c1) AS (
+  SELECT
+    listagg(col1) WITHIN GROUP (
+      ORDER BY
+        col1 COLLATE unicode_rtrim
+    )
+  FROM
+    (
+      VALUES ('abc '), ('abc\\n'), ('abc'), ('x')
+    )
+)
+SELECT
+  replace(replace(c1, ' ', ''), '\\n', '$')
+FROM
+  t;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://listagg-l6.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should format try arithmetic T1 case with spaced negative interval literal', () => {
+            const sql = `SELECT try_subtract(interval 2147483647 month, interval -2 month);`;
+            const _expected = `SELECT
+  try_subtract(interval 2147483647 month, interval - 2 month);`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://try-arithmetic-t1.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            (0, chai_1.expect)(formatted).to.be.a('string');
+        });
+        it('should keep simple compact wrapper function on one line', () => {
+            const sql = `select lower(name) as lowered from users`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://compact-wrapper.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            (0, chai_1.expect)(formatted).to.include('lower(name)');
+            (0, chai_1.expect)(formatted).to.not.include('lower(\n');
+        });
+        it('should remove space between function name and left paren', () => {
+            const sql = `table t
+|> select
+     (
+       select
+         any_value (a)
+       from
+         other
+       where
+         x = a
+       limit 1
+     ) as result;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://function-space.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('函数名和括号间空格清理结果:');
+            console.log(formatted);
+            // No space between function name and left paren
+            (0, chai_1.expect)(formatted).to.include('any_value');
+        });
+        it('should format TIMESTAMPADD function with compact mode', () => {
+            const sql = `select timestampadd(
+          
+          MONTH,
+          1,
+          timestamp'2024-01-01'
+        ) as result`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://timestampadd.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('TIMESTAMPADD 格式化结果:');
+            console.log(formatted);
+            // Should be compact without extra newlines
+            (0, chai_1.expect)(formatted).to.include('timestampadd(');
+            (0, chai_1.expect)(formatted).to.not.include('timestampadd(\n');
+        });
+        it('should format TIMESTAMPDIFF function with compact mode', () => {
+            const sql = `select timestampdiff(
+          
+          MONTH,
+          timestamp'2024-01-01',
+          timestamp'2024-02-01'
+        ) as diff`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://timestampdiff.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('TIMESTAMPDIFF 格式化结果:');
+            console.log(formatted);
+            // Should be compact without extra newlines
+            (0, chai_1.expect)(formatted).to.include('timestampdiff(');
+            (0, chai_1.expect)(formatted).to.not.include('timestampdiff(\n');
+        });
+        it('should format POSITION function with compact mode', () => {
+            const sql = `select position(
+          
+          'abc'
+          in
+          'abcdef'
+        ) as pos`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://position.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('POSITION 格式化结果:');
+            console.log(formatted);
+            // Should be compact without extra newlines
+            (0, chai_1.expect)(formatted).to.include('position(');
+            (0, chai_1.expect)(formatted).to.not.include('position(\n');
+        });
+        it('should format STRUCT function with compact mode', () => {
+            const sql = `select struct(
+          
+          a,
+          b as x,
+          c
+        ) as s`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://struct.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('STRUCT 格式化结果:');
+            console.log(formatted);
+            // Should be compact without extra newlines
+            (0, chai_1.expect)(formatted).to.include('struct(');
+            (0, chai_1.expect)(formatted).to.not.include('struct(\n');
+        });
+        it('should clear newlines between LIMIT/OFFSET and their values', () => {
+            const sql = `table t
+|> select
+     x,
+     length(y) as z
+|> limit
+ 1000 offset
+ 1
+|> where
+     x + length(y) < 4;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://limit-offset-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('LIMIT OFFSET (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // Should be compact: limit 1000 offset 1
+            (0, chai_1.expect)(formatted).to.include('limit');
+        });
+        it('should clear newlines in SET assignment expression', () => {
+            const sql = `table t
+|> set
+ z2
+= 4`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://set-newline.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('SET (含换行输入) 格式化结果:');
+            console.log(formatted);
+            // Should be compact: z2 = 4
+            (0, chai_1.expect)(formatted).to.include('z2 = 4');
+            (0, chai_1.expect)(formatted).to.not.include('z2\n');
+        });
+        it('should format valid statements even when file has parse errors', () => {
+            // File with one parse error (limit2 should be limit 2)
+            // First statement has error, second statement is valid
+            const sql = `table t |> limit2;
+
+table other |> select a;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://partial-error.sql', 'sql', 1, sql);
+            // Use returnResult: true to get FormattingResult with errors
+            const result = server.doFormatting(doc, { tabSize: 2, insertSpaces: true }, true);
+            console.log('部分错误文件格式化 result:', JSON.stringify(result, null, 2));
+            // Should have parse errors
+            (0, chai_1.expect)(result.errors.length).to.be.greaterThan(0);
+            // Should still have edits for valid parts
+            (0, chai_1.expect)(result.edits.length).to.be.greaterThan(0);
+            // Apply edits and verify valid parts are formatted
+            const formatted = applyTextEdits(sql, result.edits);
+            console.log('部分错误文件格式化结果:');
+            console.log(formatted);
+            // The valid second statement should be formatted
+            (0, chai_1.expect)(formatted).to.include('table other');
+            // Second statement should be reformatted (not single line)
+            (0, chai_1.expect)(formatted).to.include('|> select\n     a');
+        });
+        it('should clear newlines in LIMIT inside subquery', () => {
+            const sql = `table t
+|> extend
+     (
+       select
+         a
+       from
+         other
+       where
+         x = a
+       limit
+1
+     ) as z;`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://limit-in-subquery.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('子查询中 LIMIT 格式化结果:');
+            console.log(formatted);
+            // limit 1 should be compact
+            (0, chai_1.expect)(formatted).to.include('limit 1');
+            (0, chai_1.expect)(formatted).to.not.include('limit \n');
+        });
+        it('should clear extra newlines in UNPIVOT IN clause', () => {
+            const sql = `table courseEarningsAndSales
+|> unpivot include nulls (
+     (earnings, sales) for \`year\` in (
+
+
+
+
+       (earnings2012, sales2012) as \`2012\`,
+       (earnings2013, sales2013) as \`2013\`,
+       (earnings2014, sales2014) as \`2014\`
+     )
+   );`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://unpivot-newlines.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('UNPIVOT IN 子句格式化结果:');
+            console.log(formatted);
+            // Should not have multiple consecutive newlines
+            (0, chai_1.expect)(formatted).to.not.include('in (\n\n');
+            (0, chai_1.expect)(formatted).to.not.include('in (\n     \n');
+            // Should have proper format with tuples
+            (0, chai_1.expect)(formatted).to.include('as `2012`');
+            (0, chai_1.expect)(formatted).to.include('as `2013`');
+            (0, chai_1.expect)(formatted).to.include('as `2014`');
+        });
+        it('should format FROM VALUES with long content - each tuple on separate line', () => {
+            const sql = `create temporary view data as select * from values
+  ("one", array(11, 12, 13), array(array(111, 112, 113), array(121, 122, 123))),
+  ("two", array(21, 22, 23), array(array(211, 212, 213), array(221, 222, 223)))
+  as data(a, b, c);`;
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create('test://values-long.sql', 'sql', 1, sql);
+            const edits = server.doFormatting(doc, { tabSize: 2, insertSpaces: true });
+            const formatted = applyTextEdits(sql, edits);
+            console.log('FROM VALUES (长内容) 格式化结果:');
+            console.log(formatted);
+            // 验证格式化结果基本结构
+            (0, chai_1.expect)(formatted).to.include('values');
+            (0, chai_1.expect)(formatted).to.include('as data(a, b, c)');
+        });
+    });
+});
+//# sourceMappingURL=lsp-server.test.js.map