/**
 * v0.8.0 回归 —— A10 列对列比较与关联子查询
 *
 * 两个此前**静默返回空结果**的缺陷（行数正确、内容全空、无任何报错）：
 *
 * 1. `WHERE t.x = t.y`（唯一可解析的列对列写法，解析为 `{ 't.x': { $eq: { $col: 't.y' } } }`）
 *    执行路径是：引擎层先按原始 where 取候选行（引擎的 matchWhere **没有** $col 上下文）
 *    → executor.filterCorrelated 带 `{ $col: true }` 做最终判定。
 *    结果两处都错了：
 *      - 引擎层把 `{ $col: ... }` 当普通对象比较 → 所有行都不匹配；
 *      - executor 侧调用 matchWhere 时又**没传** `{ $col: true }`。
 *    实测返回 `[]`（应返回 x == y 的行）。
 *
 * 2. `WHERE id IN (SELECT ... WHERE o.user_id = u.id)`（关联 IN 子查询）
 *    子查询执行时**不传外层行上下文**，`u.id` 绑定为 null，子查询返回空集 →
 *    `$in: []` → 静默空结果。而结构相同的 EXISTS 走另一条分支、结果是正确的
 *    —— 又一处"同一语义两条路径"。
 *
 * 修复后两者与等价写法结果一致（见下方断言）。
 */
import { MetonaSqlark } from '../src/core';

const MODES: Array<[string, Record<string, unknown>]> = [
  ['memory', {}],
  ['disk', {}],
  ['hybrid', {}],
  ['aria', { diskEngine: 'memory' }],
];

describe('[v0.8.0] A10 列对列比较', () => {
  test('WHERE t.x = t.y 返回相等行（四引擎）', async () => {
    for (const [mode, extra] of MODES) {
      const db = await MetonaSqlark.create({ name: `v080-a10-${mode}`, mode, ...extra } as never);
      await db.defineTable('t', {
        id: { type: 'string', primaryKey: true },
        x: { type: 'number' },
        y: { type: 'number' },
      });
      await db.query("INSERT INTO t VALUES ('1',1,5),('2',2,3),('3',7,7),('4',7,7)");

      const rows = await db.query('SELECT id FROM t WHERE t.x = t.y') as Array<{ id: string }>;
      expect(rows.map((r) => r.id).sort()).toEqual(['3', '4']);
      await db.close();
    }
  });

  test('裸 x = y 仍为显式 PARSE_ERROR（语法限制，不静默）', async () => {
    const db = await MetonaSqlark.create({ name: 'v080-a10-bare', mode: 'memory' });
    await db.defineTable('t', { id: { type: 'string', primaryKey: true }, x: { type: 'number' }, y: { type: 'number' } });
    await expect(db.query('SELECT id FROM t WHERE x = y')).rejects.toMatchObject({ code: 'PARSE_ERROR' });
    await db.close();
  });
});

describe('[v0.8.0] A10 关联 IN 子查询', () => {
  test('关联 IN 与等价 EXISTS 结果一致（四引擎）', async () => {
    for (const [mode, extra] of MODES) {
      const db = await MetonaSqlark.create({ name: `v080-a10b-${mode}`, mode, ...extra } as never);
      await db.defineTable('u', { id: { type: 'string', primaryKey: true } });
      await db.defineTable('o', { id: { type: 'string', primaryKey: true }, user_id: { type: 'string' } });
      await db.query("INSERT INTO u VALUES ('1'),('2'),('3')");
      await db.query("INSERT INTO o VALUES ('o1','1'),('o2','2')");

      const viaIn = await db.query(
        'SELECT id FROM u WHERE id IN (SELECT user_id FROM o WHERE o.user_id = u.id)',
      ) as Array<{ id: string }>;
      const viaExists = await db.query(
        'SELECT id FROM u WHERE EXISTS (SELECT 1 FROM o WHERE o.user_id = u.id)',
      ) as Array<{ id: string }>;

      expect(viaIn.map((r) => r.id).sort()).toEqual(['1', '2']);
      // 关键护栏：两条语义等价的路径必须给出一致结果
      expect(viaIn.map((r) => r.id).sort()).toEqual(viaExists.map((r) => r.id).sort());
      await db.close();
    }
  });

  test('非关联 IN 子查询不受影响（回归护栏）', async () => {
    const db = await MetonaSqlark.create({ name: 'v080-a10c', mode: 'memory' });
    await db.defineTable('u', { id: { type: 'string', primaryKey: true } });
    await db.defineTable('o', { id: { type: 'string', primaryKey: true }, user_id: { type: 'string' } });
    await db.query("INSERT INTO u VALUES ('1'),('2'),('3')");
    await db.query("INSERT INTO o VALUES ('o1','1'),('o2','2')");

    const rows = await db.query('SELECT id FROM u WHERE id IN (SELECT user_id FROM o)') as Array<{ id: string }>;
    expect(rows.map((r) => r.id).sort()).toEqual(['1', '2']);
    await db.close();
  });
});