@tejasanik/postgres-mcp-server 1.7.1 → 2.0.0

package/dist/__tests__/sql-tools.test.js

@@ -4,11 +4,25 @@ import * as fs from 'fs';
 const mockQuery = jest.fn();
 const mockGetClient = jest.fn();
 const mockIsConnected = jest.fn();
+const mockBeginTransaction = jest.fn();
+const mockCommitTransaction = jest.fn();
+const mockRollbackTransaction = jest.fn();
+const mockQueryInTransaction = jest.fn();
+const mockGetConnectionContext = jest.fn();
 jest.unstable_mockModule('../db-manager.js', () => ({
     getDbManager: jest.fn(() => ({
         query: mockQuery,
         getClient: mockGetClient,
         isConnected: mockIsConnected.mockReturnValue(true),
+        beginTransaction: mockBeginTransaction,
+        commitTransaction: mockCommitTransaction,
+        rollbackTransaction: mockRollbackTransaction,
+        queryInTransaction: mockQueryInTransaction,
+        getConnectionContext: mockGetConnectionContext.mockReturnValue({
+            server: 'test-server',
+            database: 'test-db',
+            schema: 'public'
+        }),
     })),
     resetDbManager: jest.fn(),
 }));
@@ -16,15 +30,29 @@ jest.unstable_mockModule('../db-manager.js', () => ({
 let executeSql;
 let explainQuery;
 let executeSqlFile;
+let mutationPreview;
+let batchExecute;
+let beginTransaction;
+let commitTransaction;
+let rollbackTransaction;
+let getConnectionContext;
 beforeAll(async () => {
     const module = await import('../tools/sql-tools.js');
     executeSql = module.executeSql;
     explainQuery = module.explainQuery;
     executeSqlFile = module.executeSqlFile;
+    mutationPreview = module.mutationPreview;
+    batchExecute = module.batchExecute;
+    beginTransaction = module.beginTransaction;
+    commitTransaction = module.commitTransaction;
+    rollbackTransaction = module.rollbackTransaction;
+    getConnectionContext = module.getConnectionContext;
 });
 describe('SQL Tools', () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        // Reset mock implementations to avoid leakage between tests
+        mockQuery.mockReset();
         mockIsConnected.mockReturnValue(true);
     });
     describe('executeSql', () => {
@@ -448,6 +476,724 @@ describe('SQL Tools', () => {
             }
             expect(mockClient.release).toHaveBeenCalled();
         });
+        it('should include line numbers in errors', async () => {
+            fs.writeFileSync(testFile, `
+        SELECT 1;
+        SELECT 2;
+        INVALID SYNTAX HERE;
+        SELECT 4;
+      `);
+            mockClient.query
+                .mockResolvedValueOnce({}) // BEGIN
+                .mockResolvedValueOnce({ rowCount: 1 }) // SELECT 1
+                .mockResolvedValueOnce({ rowCount: 1 }) // SELECT 2
+                .mockRejectedValueOnce(new Error('syntax error')) // INVALID
+                .mockResolvedValueOnce({}); // ROLLBACK
+            const result = await executeSqlFile({ filePath: testFile, stopOnError: true });
+            expect(result.success).toBe(false);
+            expect(result.errors).toBeDefined();
+            expect(result.errors[0].lineNumber).toBeGreaterThan(0);
+            expect(result.errors[0].statementIndex).toBe(3);
+        });
+        it('should track line numbers correctly with multi-line statements', async () => {
+            fs.writeFileSync(testFile, `-- Comment on line 1
+SELECT
+  column1,
+  column2
+FROM table1;
+-- Line 6
+SELECT 1;
+INVALID;`);
+            mockClient.query
+                .mockResolvedValueOnce({}) // BEGIN
+                .mockResolvedValueOnce({ rowCount: 1 }) // First SELECT
+                .mockResolvedValueOnce({ rowCount: 1 }) // SELECT 1
+                .mockRejectedValueOnce(new Error('syntax error')); // INVALID
+            const result = await executeSqlFile({ filePath: testFile, stopOnError: false });
+            expect(result.errors).toBeDefined();
+            expect(result.errors.length).toBe(1);
+            // The INVALID statement starts on line 8
+            expect(result.errors[0].lineNumber).toBe(8);
+        });
+    });
+    describe('allowMultipleStatements', () => {
+        it('should execute multiple statements and return results for each', async () => {
+            mockQuery
+                .mockResolvedValueOnce({ rows: [{ id: 1 }], rowCount: 1 })
+                .mockResolvedValueOnce({ rows: [{ id: 2 }], rowCount: 1 })
+                .mockResolvedValueOnce({ rows: [{ count: 5 }], rowCount: 1 });
+            const result = await executeSql({
+                sql: 'INSERT INTO t VALUES (1); INSERT INTO t VALUES (2); SELECT COUNT(*) FROM t;',
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(3);
+            expect(result.successCount).toBe(3);
+            expect(result.failureCount).toBe(0);
+            expect(result.results).toHaveLength(3);
+        });
+        it('should include line numbers in multi-statement results', async () => {
+            mockQuery
+                .mockResolvedValueOnce({ rows: [], rowCount: 0 })
+                .mockResolvedValueOnce({ rows: [], rowCount: 0 });
+            const result = await executeSql({
+                sql: `SELECT 1;
+
+SELECT 2;`,
+                allowMultipleStatements: true
+            });
+            expect(result.results[0].lineNumber).toBe(1);
+            expect(result.results[1].lineNumber).toBe(3);
+        });
+        it('should handle errors in multi-statement execution', async () => {
+            mockQuery
+                .mockResolvedValueOnce({ rows: [], rowCount: 0 })
+                .mockRejectedValueOnce(new Error('syntax error'))
+                .mockResolvedValueOnce({ rows: [], rowCount: 0 });
+            const result = await executeSql({
+                sql: 'SELECT 1; INVALID; SELECT 3;',
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(3);
+            expect(result.successCount).toBe(2);
+            expect(result.failureCount).toBe(1);
+            expect(result.results[1].success).toBe(false);
+            expect(result.results[1].error).toContain('syntax error');
+        });
+        it('should not allow params with multiple statements', async () => {
+            await expect(executeSql({
+                sql: 'SELECT $1; SELECT $2;',
+                params: [1, 2],
+                allowMultipleStatements: true
+            })).rejects.toThrow('params not supported with allowMultipleStatements');
+        });
+        it('should skip empty statements and comments', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0 });
+            const result = await executeSql({
+                sql: `
+          -- Just a comment
+          SELECT 1;
+          /* Block comment */
+          SELECT 2;
+        `,
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(2);
+        });
+        it('should handle dollar-quoted strings in multi-statement', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0 });
+            const result = await executeSql({
+                sql: `SELECT $$has ; semicolon$$; SELECT 2;`,
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(2);
+        });
+    });
+    describe('mutationPreview', () => {
+        it('should require sql parameter', async () => {
+            await expect(mutationPreview({ sql: '' }))
+                .rejects.toThrow('sql parameter is required');
+        });
+        it('should only accept INSERT, UPDATE, DELETE statements', async () => {
+            await expect(mutationPreview({ sql: 'SELECT * FROM users' }))
+                .rejects.toThrow('SQL must be an INSERT, UPDATE, or DELETE statement');
+        });
+        it('should preview DELETE with WHERE clause', async () => {
+            mockQuery
+                .mockResolvedValueOnce({
+                rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 10 } }] }]
+            }) // EXPLAIN
+                .mockResolvedValueOnce({
+                rows: [{ id: 1 }, { id: 2 }]
+            }); // SELECT sample
+            const result = await mutationPreview({
+                sql: "DELETE FROM users WHERE status = 'inactive'"
+            });
+            expect(result.mutationType).toBe('DELETE');
+            expect(result.estimatedRowsAffected).toBe(10);
+            expect(result.sampleAffectedRows).toHaveLength(2);
+            expect(result.targetTable).toBe('users');
+            expect(result.whereClause).toBe("status = 'inactive'");
+        });
+        it('should preview UPDATE with WHERE clause', async () => {
+            mockQuery
+                .mockResolvedValueOnce({
+                rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 5 } }] }]
+            })
+                .mockResolvedValueOnce({
+                rows: [{ id: 1, name: 'Test' }]
+            });
+            const result = await mutationPreview({
+                sql: "UPDATE users SET name = 'Updated' WHERE id = 1"
+            });
+            expect(result.mutationType).toBe('UPDATE');
+            expect(result.targetTable).toBe('users');
+        });
+        it('should warn when no WHERE clause is present', async () => {
+            mockQuery
+                .mockResolvedValueOnce({
+                rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 1000 } }] }]
+            })
+                .mockResolvedValueOnce({ rows: [] })
+                .mockResolvedValueOnce({ rows: [{ cnt: '1000' }] });
+            const result = await mutationPreview({
+                sql: 'DELETE FROM users'
+            });
+            expect(result.warning).toContain('ALL rows');
+        });
+        it('should handle INSERT preview', async () => {
+            // For INSERT, only EXPLAIN is called
+            mockQuery.mockResolvedValueOnce({
+                rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 1 } }] }]
+            });
+            const result = await mutationPreview({
+                sql: "INSERT INTO users (name) VALUES ('test')"
+            });
+            expect(result.mutationType).toBe('INSERT');
+            expect(result.warning).toContain('INSERT preview cannot show affected rows');
+            expect(result.sampleAffectedRows).toHaveLength(0);
+            expect(result.estimatedRowsAffected).toBe(1);
+        });
+        it('should limit sample size', async () => {
+            mockQuery
+                .mockResolvedValueOnce({
+                rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 100 } }] }]
+            })
+                .mockResolvedValueOnce({ rows: Array(20).fill({ id: 1 }) });
+            const result = await mutationPreview({
+                sql: 'DELETE FROM users WHERE active = false',
+                sampleSize: 50 // Should be capped at 20
+            });
+            // The query should use LIMIT 20 (max)
+            expect(mockQuery).toHaveBeenCalledWith(expect.stringContaining('LIMIT 20'));
+        });
+    });
+    describe('batchExecute', () => {
+        it('should require queries parameter', async () => {
+            await expect(batchExecute({ queries: null }))
+                .rejects.toThrow('queries parameter is required');
+        });
+        it('should reject empty queries array', async () => {
+            await expect(batchExecute({ queries: [] }))
+                .rejects.toThrow('queries array cannot be empty');
+        });
+        it('should limit to 20 queries', async () => {
+            const queries = Array(21).fill(null).map((_, i) => ({
+                name: `q${i}`,
+                sql: 'SELECT 1'
+            }));
+            await expect(batchExecute({ queries }))
+                .rejects.toThrow('Maximum 20 queries allowed');
+        });
+        it('should require unique query names', async () => {
+            await expect(batchExecute({
+                queries: [
+                    { name: 'same', sql: 'SELECT 1' },
+                    { name: 'same', sql: 'SELECT 2' }
+                ]
+            })).rejects.toThrow('Duplicate query name');
+        });
+        it('should require name for each query', async () => {
+            await expect(batchExecute({
+                queries: [
+                    { name: '', sql: 'SELECT 1' }
+                ]
+            })).rejects.toThrow('Each query must have a name');
+        });
+        it('should require sql for each query', async () => {
+            await expect(batchExecute({
+                queries: [
+                    { name: 'test', sql: '' }
+                ]
+            })).rejects.toThrow('must have sql');
+        });
+        it('should execute multiple queries in parallel', async () => {
+            // For parallel tests, use a consistent mock value - order isn't guaranteed
+            mockQuery.mockResolvedValue({ rows: [{ value: 1 }], rowCount: 1 });
+            const result = await batchExecute({
+                queries: [
+                    { name: 'count', sql: 'SELECT COUNT(*) FROM users' },
+                    { name: 'sum', sql: 'SELECT SUM(amount) FROM orders' },
+                    { name: 'avg', sql: 'SELECT AVG(price) FROM products' }
+                ]
+            });
+            expect(result.totalQueries).toBe(3);
+            expect(result.successCount).toBe(3);
+            expect(result.failureCount).toBe(0);
+            expect(result.results.count.success).toBe(true);
+            expect(result.results.count.rows).toEqual([{ value: 1 }]);
+            expect(result.results.sum.success).toBe(true);
+            expect(result.results.avg.success).toBe(true);
+            expect(mockQuery).toHaveBeenCalledTimes(3);
+        });
+        it('should handle partial failures', async () => {
+            // Test with all queries succeeding first - then test single failure case
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0 });
+            const successResult = await batchExecute({
+                queries: [
+                    { name: 'q1', sql: 'SELECT 1' },
+                    { name: 'q2', sql: 'SELECT 2' }
+                ]
+            });
+            expect(successResult.successCount).toBe(2);
+            expect(successResult.failureCount).toBe(0);
+        });
+        it('should capture query errors correctly', async () => {
+            // Test single query failure
+            mockQuery.mockRejectedValue(new Error('Table not found'));
+            const result = await batchExecute({
+                queries: [
+                    { name: 'fail', sql: 'SELECT * FROM nonexistent' }
+                ]
+            });
+            expect(result.successCount).toBe(0);
+            expect(result.failureCount).toBe(1);
+            expect(result.results.fail.success).toBe(false);
+            expect(result.results.fail.error).toContain('Table not found');
+        });
+        it('should track execution time for each query', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0 });
+            const result = await batchExecute({
+                queries: [
+                    { name: 'q1', sql: 'SELECT 1' }
+                ]
+            });
+            expect(result.results.q1.executionTimeMs).toBeDefined();
+            expect(typeof result.results.q1.executionTimeMs).toBe('number');
+            expect(result.totalExecutionTimeMs).toBeDefined();
+        });
+        it('should support query parameters', async () => {
+            mockQuery.mockResolvedValue({ rows: [{ id: 1 }], rowCount: 1 });
+            await batchExecute({
+                queries: [
+                    { name: 'q1', sql: 'SELECT * FROM users WHERE id = $1', params: [123] }
+                ]
+            });
+            expect(mockQuery).toHaveBeenCalledWith('SELECT * FROM users WHERE id = $1', [123]);
+        });
+    });
+    describe('Transaction Control', () => {
+        it('should begin a transaction and return transactionId', async () => {
+            mockBeginTransaction.mockResolvedValue({
+                transactionId: 'test-tx-id',
+                server: 'test-server',
+                database: 'test-db',
+                schema: 'public',
+                startedAt: new Date()
+            });
+            const result = await beginTransaction();
+            expect(result.transactionId).toBe('test-tx-id');
+            expect(result.status).toBe('started');
+            expect(result.message).toContain('test-tx-id');
+        });
+        it('should commit a transaction', async () => {
+            mockCommitTransaction.mockResolvedValue(undefined);
+            const result = await commitTransaction({ transactionId: 'test-tx-id' });
+            expect(result.status).toBe('committed');
+            expect(mockCommitTransaction).toHaveBeenCalledWith('test-tx-id');
+        });
+        it('should require transactionId for commit', async () => {
+            await expect(commitTransaction({ transactionId: '' }))
+                .rejects.toThrow('transactionId is required');
+        });
+        it('should rollback a transaction', async () => {
+            mockRollbackTransaction.mockResolvedValue(undefined);
+            const result = await rollbackTransaction({ transactionId: 'test-tx-id' });
+            expect(result.status).toBe('rolled_back');
+            expect(mockRollbackTransaction).toHaveBeenCalledWith('test-tx-id');
+        });
+        it('should require transactionId for rollback', async () => {
+            await expect(rollbackTransaction({ transactionId: '' }))
+                .rejects.toThrow('transactionId is required');
+        });
+        it('should execute query within transaction', async () => {
+            mockQueryInTransaction.mockResolvedValue({
+                rows: [{ id: 1 }],
+                rowCount: 1,
+                fields: [{ name: 'id' }]
+            });
+            const result = await executeSql({
+                sql: 'SELECT * FROM users',
+                transactionId: 'test-tx-id'
+            });
+            expect(mockQueryInTransaction).toHaveBeenCalledWith('test-tx-id', 'SELECT * FROM users', undefined);
+            expect(result.rows).toEqual([{ id: 1 }]);
+        });
+        it('should use transactionId with multi-statement execution', async () => {
+            mockQueryInTransaction
+                .mockResolvedValueOnce({ rows: [], rowCount: 0 })
+                .mockResolvedValueOnce({ rows: [], rowCount: 0 });
+            const result = await executeSql({
+                sql: 'INSERT INTO t VALUES (1); SELECT * FROM t;',
+                allowMultipleStatements: true,
+                transactionId: 'test-tx-id'
+            });
+            expect(mockQueryInTransaction).toHaveBeenCalledTimes(2);
+            expect(result.totalStatements).toBe(2);
+        });
+    });
+    describe('getConnectionContext', () => {
+        it('should return current connection context', () => {
+            const context = getConnectionContext();
+            expect(context).toEqual({
+                server: 'test-server',
+                database: 'test-db',
+                schema: 'public'
+            });
+        });
+    });
+    describe('includeSchemaHint', () => {
+        it('should include schema hints when requested', async () => {
+            // Schema hint queries run FIRST (columns, pk, fk, count), then main query
+            mockQuery
+                // 1. Mock for columns query (schema hint - runs first)
+                .mockResolvedValueOnce({
+                rows: [
+                    { name: 'id', type: 'integer', nullable: false },
+                    { name: 'name', type: 'text', nullable: true }
+                ]
+            })
+                // 2. Mock for primary key query (schema hint)
+                .mockResolvedValueOnce({
+                rows: [{ column_name: 'id' }]
+            })
+                // 3. Mock for foreign keys query (schema hint)
+                .mockResolvedValueOnce({ rows: [] })
+                // 4. Mock for row count estimate (schema hint)
+                .mockResolvedValueOnce({
+                rows: [{ estimate: 1000 }]
+            })
+                // 5. Mock for main query (runs last)
+                .mockResolvedValueOnce({
+                rows: [{ id: 1 }],
+                rowCount: 1,
+                fields: [{ name: 'id' }]
+            });
+            const result = await executeSql({
+                sql: 'SELECT * FROM users',
+                includeSchemaHint: true
+            });
+            expect(result.schemaHint).toBeDefined();
+            expect(result.schemaHint.tables).toHaveLength(1);
+            expect(result.schemaHint.tables[0].table).toBe('users');
+            expect(result.schemaHint.tables[0].columns).toHaveLength(2);
+            expect(result.schemaHint.tables[0].primaryKey).toContain('id');
+        });
+        it('should extract tables from JOIN queries', async () => {
+            mockQuery.mockResolvedValue({
+                rows: [],
+                rowCount: 0,
+                fields: []
+            });
+            await executeSql({
+                sql: 'SELECT * FROM orders o JOIN customers c ON o.customer_id = c.id',
+                includeSchemaHint: true
+            });
+            // Should query schema info for both tables
+            expect(mockQuery).toHaveBeenCalledWith(expect.stringContaining('information_schema.columns'), ['public', 'orders']);
+        });
+        it('should handle schema-qualified table names', async () => {
+            mockQuery.mockResolvedValue({
+                rows: [],
+                rowCount: 0,
+                fields: []
+            });
+            await executeSql({
+                sql: 'SELECT * FROM myschema.users',
+                includeSchemaHint: true
+            });
+            expect(mockQuery).toHaveBeenCalledWith(expect.stringContaining('information_schema.columns'), ['myschema', 'users']);
+        });
+        it('should not include schema hints when not requested', async () => {
+            mockQuery.mockResolvedValue({
+                rows: [],
+                rowCount: 0,
+                fields: []
+            });
+            const result = await executeSql({
+                sql: 'SELECT * FROM users',
+                includeSchemaHint: false
+            });
+            expect(result.schemaHint).toBeUndefined();
+        });
+    });
+    describe('SQL Parsing Safety (ReDoS Prevention)', () => {
+        // These tests ensure the regex patterns don't cause infinite loops or excessive backtracking
+        it('should handle deeply nested comments without hanging', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const nestedComments = '/* outer /* inner */ still outer */ SELECT 1;';
+            const result = await executeSql({
+                sql: nestedComments,
+                allowMultipleStatements: true
+            });
+            // Should complete quickly without hanging
+            expect(result).toBeDefined();
+        });
+        it('should handle many semicolons without performance issues', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            // Create string with many semicolons
+            const manySemicolons = 'SELECT 1' + ';'.repeat(100);
+            const startTime = Date.now();
+            const result = await executeSql({
+                sql: manySemicolons,
+                allowMultipleStatements: true
+            });
+            const duration = Date.now() - startTime;
+            // Should complete in under 1 second
+            expect(duration).toBeLessThan(1000);
+        });
+        it('should handle long strings of repeated characters safely', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            // Potential ReDoS pattern - many repeated characters
+            const longRepeat = 'SELECT ' + 'a'.repeat(10000);
+            const startTime = Date.now();
+            await expect(executeSql({
+                sql: longRepeat,
+                allowMultipleStatements: true
+            })).resolves.toBeDefined();
+            const duration = Date.now() - startTime;
+            expect(duration).toBeLessThan(2000);
+        });
+        it('should handle alternating quotes safely', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            // Alternating quotes that could confuse parsers
+            const alternating = `SELECT '"'"'"'"'"'"'";`;
+            const result = await executeSql({
+                sql: alternating,
+                allowMultipleStatements: true
+            });
+            expect(result).toBeDefined();
+        });
+        it('should handle unclosed dollar quotes gracefully', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            // Unclosed dollar quote
+            const unclosed = 'SELECT $tag$never closed';
+            const startTime = Date.now();
+            const result = await executeSql({
+                sql: unclosed,
+                allowMultipleStatements: true
+            });
+            const duration = Date.now() - startTime;
+            expect(duration).toBeLessThan(1000);
+            expect(result.totalStatements).toBe(1);
+        });
+        it('should handle pathological backtracking patterns in comments', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            // Pattern that could cause exponential backtracking
+            const pathological = '/*' + '*'.repeat(1000) + '/ SELECT 1;';
+            const startTime = Date.now();
+            const result = await executeSql({
+                sql: pathological,
+                allowMultipleStatements: true
+            });
+            const duration = Date.now() - startTime;
+            expect(duration).toBeLessThan(1000);
+        });
+        it('should handle very long line comments', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const longComment = '-- ' + 'x'.repeat(50000) + '\nSELECT 1;';
+            const startTime = Date.now();
+            const result = await executeSql({
+                sql: longComment,
+                allowMultipleStatements: true
+            });
+            const duration = Date.now() - startTime;
+            expect(duration).toBeLessThan(2000);
+            expect(result.totalStatements).toBe(1);
+        });
+        it('should handle multiple dollar-quote tags in sequence', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const multiDollar = `
+        SELECT $a$test$a$;
+        SELECT $b$test$b$;
+        SELECT $$test$$;
+      `;
+            const result = await executeSql({
+                sql: multiDollar,
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(3);
+        });
+        it('should handle mixed quote styles without confusion', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const mixedQuotes = `
+        SELECT 'single "with" double';
+        SELECT "double 'with' single";
+        SELECT $$dollar 'with' all "kinds"$$;
+      `;
+            const result = await executeSql({
+                sql: mixedQuotes,
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(3);
+        });
+        it('should handle escaped quotes correctly', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const escapedQuotes = `SELECT 'it''s escaped'; SELECT "double""quote";`;
+            const result = await executeSql({
+                sql: escapedQuotes,
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(2);
+        });
+    });
+    describe('Table Extraction Safety', () => {
+        it('should extract tables from complex JOIN chains', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            await executeSql({
+                sql: `
+          SELECT * FROM t1
+          JOIN t2 ON t1.id = t2.t1_id
+          LEFT JOIN t3 ON t2.id = t3.t2_id
+          RIGHT JOIN t4 ON t3.id = t4.t3_id
+          INNER JOIN t5 ON t4.id = t5.t4_id
+        `,
+                includeSchemaHint: true
+            });
+            // Should have attempted to fetch schema for multiple tables
+            const calls = mockQuery.mock.calls;
+            const schemaCalls = calls.filter((c) => c[0] && c[0].includes('information_schema'));
+            expect(schemaCalls.length).toBeGreaterThanOrEqual(1);
+        });
+        it('should handle subqueries without extracting them as tables', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            await executeSql({
+                sql: `SELECT * FROM (SELECT 1) AS subq`,
+                includeSchemaHint: true
+            });
+            // Should not try to look up "subq" as a real table
+            expect(mockQuery).toHaveBeenCalled();
+        });
+        it('should handle very long table names', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const longTableName = 'a'.repeat(63); // Max PostgreSQL identifier length
+            await executeSql({
+                sql: `SELECT * FROM ${longTableName}`,
+                includeSchemaHint: true
+            });
+            expect(mockQuery).toHaveBeenCalledWith(expect.stringContaining('information_schema'), ['public', longTableName]);
+        });
+        it('should handle quoted identifiers', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            await executeSql({
+                sql: `SELECT * FROM "MyTable" JOIN "schema"."OtherTable" ON 1=1`,
+                includeSchemaHint: true
+            });
+            // Should extract both table names correctly
+            expect(mockQuery).toHaveBeenCalledWith(expect.stringContaining('information_schema'), expect.arrayContaining(['MyTable']));
+        });
+    });
+    describe('Edge Cases in Statement Splitting', () => {
+        it('should handle empty SQL gracefully', async () => {
+            await expect(executeSql({ sql: '' }))
+                .rejects.toThrow('cannot be empty');
+        });
+        it('should handle SQL with only whitespace', async () => {
+            await expect(executeSql({ sql: '   \n\t  ' }))
+                .rejects.toThrow('cannot be empty');
+        });
+        it('should handle SQL with only comments', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const result = await executeSql({
+                sql: '-- just a comment\n/* block comment */',
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(0);
+        });
+        it('should handle statement ending without semicolon', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const result = await executeSql({
+                sql: 'SELECT 1',
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(1);
+        });
+        it('should handle multiple empty lines between statements', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const result = await executeSql({
+                sql: 'SELECT 1;\n\n\n\n\nSELECT 2;',
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(2);
+            expect(result.results[0].lineNumber).toBe(1);
+            expect(result.results[1].lineNumber).toBe(6);
+        });
+        it('should handle carriage returns correctly', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const result = await executeSql({
+                sql: 'SELECT 1;\r\nSELECT 2;\r\nSELECT 3;',
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(3);
+        });
+        it('should handle Unicode characters in statements', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            const result = await executeSql({
+                sql: "SELECT '日本語'; SELECT 'émoji 🎉';",
+                allowMultipleStatements: true
+            });
+            expect(result.totalStatements).toBe(2);
+        });
+        it('should handle null bytes safely', async () => {
+            mockQuery.mockResolvedValue({ rows: [], rowCount: 0, fields: [] });
+            // SQL with null byte should still parse
+            const withNull = 'SELECT 1;\x00SELECT 2;';
+            const result = await executeSql({
+                sql: withNull,
+                allowMultipleStatements: true
+            });
+            expect(result).toBeDefined();
+        });
+    });
+    describe('Mutation Preview Edge Cases', () => {
+        it('should handle UPDATE with multiple SET clauses', async () => {
+            mockQuery
+                .mockResolvedValueOnce({ rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 1 } }] }] })
+                .mockResolvedValueOnce({ rows: [] });
+            const result = await mutationPreview({
+                sql: "UPDATE users SET name = 'test', email = 'test@test.com', updated_at = NOW() WHERE id = 1"
+            });
+            expect(result.mutationType).toBe('UPDATE');
+            expect(result.targetTable).toBe('users');
+            expect(result.whereClause).toBe('id = 1');
+        });
+        it('should handle DELETE with complex WHERE clause', async () => {
+            mockQuery
+                .mockResolvedValueOnce({ rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 5 } }] }] })
+                .mockResolvedValueOnce({ rows: [] });
+            const result = await mutationPreview({
+                sql: `DELETE FROM orders WHERE status = 'cancelled' AND created_at < '2024-01-01' OR amount = 0`
+            });
+            expect(result.mutationType).toBe('DELETE');
+            expect(result.whereClause).toContain('cancelled');
+        });
+        it('should handle schema-qualified table in UPDATE', async () => {
+            mockQuery
+                .mockResolvedValueOnce({ rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 1 } }] }] })
+                .mockResolvedValueOnce({ rows: [] });
+            const result = await mutationPreview({
+                sql: "UPDATE myschema.users SET name = 'test' WHERE id = 1"
+            });
+            expect(result.targetTable).toBe('myschema.users');
+        });
+        it('should handle quoted table names in DELETE', async () => {
+            mockQuery
+                .mockResolvedValueOnce({ rows: [{ 'QUERY PLAN': [{ Plan: { 'Plan Rows': 1 } }] }] })
+                .mockResolvedValueOnce({ rows: [] });
+            const result = await mutationPreview({
+                sql: `DELETE FROM "MyTable" WHERE id = 1`
+            });
+            expect(result.targetTable).toBe('MyTable');
+        });
+        it('should fallback to COUNT when EXPLAIN fails', async () => {
+            mockQuery
+                .mockRejectedValueOnce(new Error('EXPLAIN failed'))
+                .mockResolvedValueOnce({ rows: [] })
+                .mockResolvedValueOnce({ rows: [{ cnt: '42' }] });
+            const result = await mutationPreview({
+                sql: "DELETE FROM users WHERE status = 'old'"
+            });
+            expect(result.estimatedRowsAffected).toBe(42);
+        });
     });
 });
 //# sourceMappingURL=sql-tools.test.js.map