376 lines
15 KiB
TypeScript
376 lines
15 KiB
TypeScript
/**
|
||
* v0.3.0 SQL 功能扩展测试
|
||
* @module tests/sql-ext
|
||
*
|
||
* 覆盖：多语句 / 事务语句 / INSERT...SELECT / UNION / CREATE INDEX / EXISTS
|
||
*/
|
||
import { MetonaSqlark } from '../src/core';
|
||
import '../src/connection-manager';
|
||
import { parse, parseAll } from '../src/sql/parser';
|
||
|
||
import { installOPFSMock } from './helpers/opfs-mock';
|
||
|
||
beforeEach(() => { installOPFSMock(new Map()); });
|
||
|
||
async function createDb(mode: 'memory' | 'disk' | 'aria' = 'memory') {
|
||
const db = new MetonaSqlark({ name: `sql-ext-${mode}-${Date.now()}-${Math.random()}`, mode, diskEngine: 'opfs' });
|
||
await db.init();
|
||
await db.defineTable('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
age: { type: 'number' },
|
||
city: { type: 'string' },
|
||
});
|
||
await db.defineTable('orders', {
|
||
id: { type: 'string', primaryKey: true },
|
||
user_id: { type: 'string' },
|
||
amount: { type: 'number' },
|
||
});
|
||
await db.query(`INSERT INTO users VALUES ('u1', 'Alice', 30, 'Beijing')`);
|
||
await db.query(`INSERT INTO users VALUES ('u2', 'Bob', 25, 'Shanghai')`);
|
||
await db.query(`INSERT INTO users VALUES ('u3', 'Carol', 35, 'Beijing')`);
|
||
await db.query(`INSERT INTO users VALUES ('u4', 'Dave', 28, 'Shenzhen')`);
|
||
await db.query(`INSERT INTO orders VALUES ('o1', 'u1', 100)`);
|
||
await db.query(`INSERT INTO orders VALUES ('o2', 'u1', 200)`);
|
||
await db.query(`INSERT INTO orders VALUES ('o3', 'u2', 50)`);
|
||
return db;
|
||
}
|
||
|
||
// ===================================================================
|
||
// 多语句 parseAll
|
||
// ===================================================================
|
||
|
||
describe('[v0.3.0] 多语句支持', () => {
|
||
test('parseAll 解析分号分隔的多条语句', () => {
|
||
const stmts = parseAll('SELECT * FROM a; INSERT INTO b VALUES (1); DELETE FROM c WHERE id = 1');
|
||
expect(stmts).toHaveLength(3);
|
||
expect(stmts[0].type).toBe('SELECT');
|
||
expect(stmts[1].type).toBe('INSERT');
|
||
expect(stmts[2].type).toBe('DELETE');
|
||
});
|
||
|
||
test('parseAll 忽略多余分号与尾部空语句', () => {
|
||
const stmts = parseAll(';;SELECT * FROM a;;;');
|
||
expect(stmts).toHaveLength(1);
|
||
expect(stmts[0].type).toBe('SELECT');
|
||
});
|
||
|
||
test('parseAll 支持事务语句', () => {
|
||
const stmts = parseAll('BEGIN; INSERT INTO a VALUES (1); COMMIT');
|
||
expect(stmts.map((s) => s.type)).toEqual(['BEGIN', 'INSERT', 'COMMIT']);
|
||
});
|
||
|
||
test('parse 保持单语句兼容', () => {
|
||
expect(parse('SELECT * FROM a').type).toBe('SELECT');
|
||
});
|
||
|
||
test('parseAll 语句间缺分号报错', () => {
|
||
expect(() => parseAll('SELECT * FROM a SELECT * FROM b')).toThrow(/Expected ';'/);
|
||
});
|
||
|
||
test('core.query 顺序执行多语句', async () => {
|
||
const db = await createDb();
|
||
await db.query('CREATE TABLE logs (id STRING PRIMARY KEY, msg STRING); INSERT INTO logs VALUES (\'l1\', \'hello\'); INSERT INTO logs VALUES (\'l2\', \'world\')');
|
||
const rows = await db.query('SELECT * FROM logs') as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
});
|
||
|
||
// ===================================================================
|
||
// 事务语句 BEGIN / COMMIT / ROLLBACK
|
||
// ===================================================================
|
||
|
||
describe('[v0.3.0] 事务语句', () => {
|
||
test('BEGIN + INSERT + COMMIT 持久化', async () => {
|
||
const db = await createDb();
|
||
await db.query('BEGIN');
|
||
await db.query(`INSERT INTO users VALUES ('u5', 'Eve', 22, 'Beijing')`);
|
||
const visible = await db.query('SELECT * FROM users') as Record<string, unknown>[];
|
||
expect(visible).toHaveLength(5); // 事务内可见
|
||
await db.query('COMMIT');
|
||
const after = await db.query('SELECT * FROM users') as Record<string, unknown>[];
|
||
expect(after).toHaveLength(5);
|
||
await db.close();
|
||
});
|
||
|
||
test('BEGIN + INSERT + ROLLBACK 回滚', async () => {
|
||
const db = await createDb();
|
||
await db.query('BEGIN');
|
||
await db.query(`INSERT INTO users VALUES ('u5', 'Eve', 22, 'Beijing')`);
|
||
await db.query('ROLLBACK');
|
||
const after = await db.query('SELECT * FROM users') as Record<string, unknown>[];
|
||
expect(after).toHaveLength(4);
|
||
await db.close();
|
||
});
|
||
|
||
test('BEGIN 嵌套报错', async () => {
|
||
const db = await createDb();
|
||
await db.query('BEGIN');
|
||
await expect(db.query('BEGIN')).rejects.toThrow(/TX_ACTIVE|Transaction already/);
|
||
await db.query('ROLLBACK');
|
||
await db.close();
|
||
});
|
||
|
||
test('无事务时 COMMIT 报错', async () => {
|
||
const db = await createDb();
|
||
await expect(db.query('COMMIT')).rejects.toThrow(/TX_NONE|No active transaction/);
|
||
await db.close();
|
||
});
|
||
|
||
test('事务语句在 Aria 引擎上可用', async () => {
|
||
const db = await createDb('aria');
|
||
await db.query('BEGIN');
|
||
await db.query(`INSERT INTO users VALUES ('u5', 'Eve', 22, 'Beijing')`);
|
||
await db.query('ROLLBACK');
|
||
const after = await db.query('SELECT * FROM users') as Record<string, unknown>[];
|
||
expect(after).toHaveLength(4);
|
||
await db.close();
|
||
});
|
||
});
|
||
|
||
// ===================================================================
|
||
// INSERT INTO ... SELECT
|
||
// ===================================================================
|
||
|
||
describe('[v0.3.0] INSERT INTO ... SELECT', () => {
|
||
test('INSERT SELECT 全列复制', async () => {
|
||
const db = await createDb();
|
||
await db.defineTable('users_backup', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
age: { type: 'number' },
|
||
city: { type: 'string' },
|
||
});
|
||
await db.query('INSERT INTO users_backup SELECT * FROM users');
|
||
const rows = await db.query('SELECT * FROM users_backup') as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(4);
|
||
expect(rows[0].name).toBe('Alice');
|
||
await db.close();
|
||
});
|
||
|
||
test('INSERT SELECT 带 WHERE 过滤', async () => {
|
||
const db = await createDb();
|
||
await db.defineTable('beijing_users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
age: { type: 'number' },
|
||
city: { type: 'string' },
|
||
});
|
||
await db.query(`INSERT INTO beijing_users SELECT * FROM users WHERE city = 'Beijing'`);
|
||
const rows = await db.query('SELECT * FROM beijing_users') as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
|
||
test('INSERT SELECT 指定列映射', async () => {
|
||
const db = await createDb();
|
||
await db.defineTable('names', { id: { type: 'string', primaryKey: true }, n: { type: 'string' } });
|
||
await db.query('INSERT INTO names (id, n) SELECT id, name FROM users');
|
||
const rows = await db.query('SELECT * FROM names') as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(4);
|
||
expect(rows[0].n).toBe('Alice');
|
||
await db.close();
|
||
});
|
||
|
||
test('INSERT SELECT 语法解析', () => {
|
||
const stmt = parse('INSERT INTO a (x, y) SELECT p, q FROM b WHERE r > 1') as any;
|
||
expect(stmt.type).toBe('INSERT');
|
||
expect(stmt.select).toBeDefined();
|
||
expect(stmt.select.type).toBe('SELECT');
|
||
expect(stmt.columns).toEqual(['x', 'y']);
|
||
});
|
||
});
|
||
|
||
// ===================================================================
|
||
// UNION / UNION ALL
|
||
// ===================================================================
|
||
|
||
describe('[v0.3.0] UNION / UNION ALL', () => {
|
||
test('UNION 去重合并', async () => {
|
||
const db = await createDb();
|
||
const rows = await db.query(`SELECT name FROM users WHERE city = 'Beijing' UNION SELECT name FROM users WHERE age < 30`) as Record<string, unknown>[];
|
||
// Beijing: Alice, Carol（Alice 同时 age30 不重复）；age<30: Bob, Dave
|
||
expect(rows).toHaveLength(4);
|
||
await db.close();
|
||
});
|
||
|
||
test('UNION ALL 不去重', async () => {
|
||
const db = await createDb();
|
||
const rows = await db.query(`SELECT city FROM users WHERE city = 'Beijing' UNION ALL SELECT city FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(4); // 2 + 2
|
||
await db.close();
|
||
});
|
||
|
||
test('UNION 对相同行去重', async () => {
|
||
const db = await createDb();
|
||
const rows = await db.query(`SELECT city FROM users WHERE city = 'Beijing' UNION SELECT city FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
// 左右各 2 行同值 → 去重后 1 行
|
||
expect(rows).toHaveLength(1);
|
||
expect(rows[0].city).toBe('Beijing');
|
||
await db.close();
|
||
});
|
||
|
||
test('UNION 链式（三表合并）', async () => {
|
||
const db = await createDb();
|
||
await db.query(`INSERT INTO users VALUES ('u5', 'Eve', 22, 'Beijing')`);
|
||
const rows = await db.query(`SELECT city FROM users WHERE city = 'Beijing' UNION SELECT city FROM users WHERE city = 'Shanghai' UNION SELECT city FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
// Beijing(3) + Shanghai(1) + Beijing(3 重复去重) → 2 个城市
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
|
||
test('UNION 语法解析', () => {
|
||
const stmt = parse('SELECT a FROM t1 UNION SELECT b FROM t2') as any;
|
||
expect(stmt.type).toBe('SELECT_UNION');
|
||
expect(stmt.all).toBeUndefined();
|
||
const stmtAll = parse('SELECT a FROM t1 UNION ALL SELECT b FROM t2') as any;
|
||
expect(stmtAll.type).toBe('SELECT_UNION');
|
||
expect(stmtAll.all).toBe(true);
|
||
});
|
||
|
||
test('UNION 在 Aria 引擎上可用', async () => {
|
||
const db = await createDb('aria');
|
||
const rows = await db.query(`SELECT city FROM users WHERE city = 'Beijing' UNION SELECT city FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(1);
|
||
await db.close();
|
||
});
|
||
});
|
||
|
||
// ===================================================================
|
||
// CREATE INDEX / DROP INDEX
|
||
// ===================================================================
|
||
|
||
describe('[v0.3.0] CREATE INDEX / DROP INDEX', () => {
|
||
test('CREATE INDEX 后索引查询可用（Memory）', async () => {
|
||
const db = await createDb();
|
||
await db.query('CREATE INDEX idx_users_city ON users (city)');
|
||
const rows = await db.query(`SELECT * FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
|
||
test('CREATE INDEX 后索引查询可用（Aria）', async () => {
|
||
const db = await createDb('aria');
|
||
await db.query('CREATE INDEX idx_users_city ON users (city)');
|
||
const rows = await db.query(`SELECT * FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
|
||
test('CREATE INDEX 对已有数据立即生效（索引填充）', async () => {
|
||
const db = await createDb();
|
||
await db.query('INSERT INTO users VALUES (\'u5\', \'Eve\', 22, \'Beijing\')');
|
||
await db.query('CREATE INDEX idx_users_age ON users (age)');
|
||
const rows = await db.query(`SELECT * FROM users WHERE age = 22`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(1);
|
||
expect(rows[0].id).toBe('u5');
|
||
await db.close();
|
||
});
|
||
|
||
test('DROP INDEX 后查询回退全表扫描', async () => {
|
||
const db = await createDb();
|
||
await db.query('CREATE INDEX idx_users_city ON users (city)');
|
||
await db.query('DROP INDEX idx_users_city ON users (city)');
|
||
const rows = await db.query(`SELECT * FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
|
||
test('CREATE INDEX 重复创建幂等', async () => {
|
||
const db = await createDb();
|
||
await db.query('CREATE INDEX idx_users_city ON users (city)');
|
||
await db.query('CREATE INDEX idx_users_city ON users (city)'); // 不抛错
|
||
const rows = await db.query(`SELECT * FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
|
||
test('CREATE INDEX 不存在列报错', async () => {
|
||
const db = await createDb();
|
||
const err = await db.query('CREATE INDEX idx_bad ON users (nonexistent)').catch((e: any) => e);
|
||
expect(err).toBeDefined();
|
||
expect(err.code).toBe('COLUMN_NOT_FOUND');
|
||
await db.close();
|
||
});
|
||
|
||
test('CREATE INDEX 后插入新数据索引同步更新', async () => {
|
||
const db = await createDb();
|
||
await db.query('CREATE INDEX idx_users_city ON users (city)');
|
||
await db.query('INSERT INTO users VALUES (\'u5\', \'Eve\', 22, \'Beijing\')');
|
||
const rows = await db.query(`SELECT * FROM users WHERE city = 'Beijing'`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(3);
|
||
await db.close();
|
||
});
|
||
|
||
test('DROP INDEX Aria 主键索引受保护', async () => {
|
||
const db = await createDb('aria');
|
||
await expect(db.query('DROP INDEX pk ON users (id)')).rejects.toThrow(/Cannot drop primary key/);
|
||
await db.close();
|
||
});
|
||
|
||
test('CREATE UNIQUE INDEX 语法解析', () => {
|
||
const stmt = parse('CREATE UNIQUE INDEX idx_u ON users (email)') as any;
|
||
expect(stmt.type).toBe('CREATE_INDEX');
|
||
expect(stmt.unique).toBe(true);
|
||
expect(stmt.column).toBe('email');
|
||
});
|
||
|
||
test('CREATE INDEX / DROP INDEX 语法解析', () => {
|
||
const stmt = parse('CREATE INDEX idx_c ON users (city)') as any;
|
||
expect(stmt).toMatchObject({ type: 'CREATE_INDEX', name: 'idx_c', table: 'users', column: 'city' });
|
||
const drop = parse('DROP INDEX idx_c ON users (city)') as any;
|
||
expect(drop).toMatchObject({ type: 'DROP_INDEX', name: 'idx_c', table: 'users', column: 'city' });
|
||
});
|
||
});
|
||
|
||
// ===================================================================
|
||
// EXISTS / NOT EXISTS
|
||
// ===================================================================
|
||
|
||
describe('[v0.3.0] EXISTS / NOT EXISTS', () => {
|
||
test('EXISTS 子查询为真返回行', async () => {
|
||
const db = await createDb();
|
||
const rows = await db.query(`SELECT * FROM users u WHERE EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id)`) as Record<string, unknown>[];
|
||
// 有订单的用户：u1, u2
|
||
expect(rows).toHaveLength(2);
|
||
expect(rows.map((r) => r.id).sort()).toEqual(['u1', 'u2']);
|
||
await db.close();
|
||
});
|
||
|
||
test('NOT EXISTS 返回无关联行', async () => {
|
||
const db = await createDb();
|
||
const rows = await db.query(`SELECT * FROM users u WHERE NOT EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id)`) as Record<string, unknown>[];
|
||
// 无订单用户：u3, u4
|
||
expect(rows).toHaveLength(2);
|
||
expect(rows.map((r) => r.id).sort()).toEqual(['u3', 'u4']);
|
||
await db.close();
|
||
});
|
||
|
||
test('EXISTS 与 AND 组合', async () => {
|
||
const db = await createDb();
|
||
const rows = await db.query(`SELECT * FROM users u WHERE EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id AND o.amount > 150) AND u.city = 'Beijing'`) as Record<string, unknown>[];
|
||
// o2 金额 200 > 150 属于 u1（Beijing）
|
||
expect(rows).toHaveLength(1);
|
||
expect(rows[0].id).toBe('u1');
|
||
await db.close();
|
||
});
|
||
|
||
test('EXISTS 语法解析', () => {
|
||
const stmt = parse(`SELECT * FROM users WHERE EXISTS (SELECT 1 FROM orders)`) as any;
|
||
expect(stmt.where.$exists).toBeDefined();
|
||
expect(stmt.where.$exists.$subquery.type).toBe('SELECT');
|
||
|
||
const notStmt = parse(`SELECT * FROM users WHERE NOT EXISTS (SELECT 1 FROM orders)`) as any;
|
||
expect(notStmt.where.$exists).toBeDefined();
|
||
expect(notStmt.where.$exists.$negate).toBe(true);
|
||
});
|
||
|
||
test('EXISTS 在 Aria 引擎上可用', async () => {
|
||
const db = await createDb('aria');
|
||
const rows = await db.query(`SELECT * FROM users u WHERE EXISTS (SELECT 1 FROM orders o WHERE o.user_id = u.id)`) as Record<string, unknown>[];
|
||
expect(rows).toHaveLength(2);
|
||
await db.close();
|
||
});
|
||
});
|