@morlay/rdbkit 0.0.0-stage → 0.0.1-alpha.3

package/src/__tests__/query-p1.spec.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import {
+  column,
+  defineTable,
+  ensureSchema,
+  eq,
+  forUpdate,
+  fragment,
+  gt,
+  openDatabase,
+  render,
+  union,
+  value,
+  withCtes,
+  type QueryEvent,
+} from "../index.ts";
+
+const items = defineTable({
+  name: "t_items",
+  columns: {
+    f_id: { type: "serial", primaryKey: true },
+    f_key: { type: "text", notNull: true, unique: true },
+    f_count: { type: "integer", notNull: true, default: 0 },
+  },
+});
+
+describe("P1：join 变体 / CTE / UNION / 行锁 / 查询观测", () => {
+  it("join 变体与别名、CTE、UNION 的 SQL 形状（两方言）", () => {
+    const table = defineTable(items);
+    const query = { table } as never;
+    void query;
+    const left = fragment('SELECT "f_id" FROM "t_items" WHERE "f_count" > ?', [1]);
+    const right = fragment('SELECT "f_id" FROM "t_items" WHERE "f_count" > ?', [2]);
+    expect(render(union(left, right), "sqlite")).toEqual({
+      text: 'SELECT "f_id" FROM "t_items" WHERE "f_count" > ? UNION SELECT "f_id" FROM "t_items" WHERE "f_count" > ?',
+      params: [1, 2],
+    });
+    expect(render(union(left, right, { all: true }), "postgres").text).toContain("UNION ALL");
+
+    const cte = withCtes(
+      [{ name: "recent", query: left }],
+      fragment('SELECT "f_id" FROM "recent"'),
+    );
+    expect(render(cte, "postgres").text).toBe(
+      'WITH "recent" AS ( SELECT "f_id" FROM "t_items" WHERE "f_count" > $1 ) SELECT "f_id" FROM "recent"',
+    );
+
+    // 行锁只有 PostgreSQL 认：SQLite 渲染时整段丢掉（参数也不留）。
+    expect(render(forUpdate({ skipLocked: true }), "sqlite")).toEqual({ text: "", params: [] });
+    expect(render(forUpdate({ skipLocked: true }), "postgres").text).toBe("FOR UPDATE SKIP LOCKED");
+  });
+
+  it("实跑：join 别名、CTE、UNION、查询观测", async () => {
+    const events: QueryEvent[] = [];
+    const database = await openDatabase({
+      dialect: "sqlite",
+      path: ":memory:",
+      onQuery: (event) => events.push(event),
+    });
+    try {
+      await ensureSchema(database, [items]);
+      const table = database.table(items);
+      await table.insertMany([
+        { f_key: "a", f_count: 1 },
+        { f_key: "b", f_count: 2 },
+      ]);
+
+      // join 别名 + 左连接
+      const rows: { key: string; other: string | null }[] = [];
+      for await (const row of table
+        .select({ key: table.column("f_key"), other: column("f_key", "o") })
+        .join(items, eq(column("f_id", "o"), column("f_id", "t_items")), "left", "o")
+        .orderBy("f_key")) {
+        rows.push(row as never);
+      }
+      expect(rows.map((row) => row.key)).toEqual(["a", "b"]);
+
+      // CTE + 主查询
+      const cte = withCtes(
+        [{ name: "recent", query: table.select({ id: table.column("f_id") }).toFragment() }],
+        fragment('SELECT "id" FROM "recent" ORDER BY "id"'),
+      );
+      const ids = await database.read<{ id: number }>(cte);
+      expect(ids.map((row) => row.id)).toEqual([1, 2]);
+
+      // UNION
+      const merged = await database.read<{ id: number }>(
+        union(
+          table
+            .select({ id: table.column("f_id") })
+            .where(gt(column("f_count"), value(1)))
+            .toFragment(),
+          table
+            .select({ id: table.column("f_id") })
+            .where(eq(column("f_key"), value("a")))
+            .toFragment(),
+        ),
+      );
+      expect(new Set(merged.map((row) => row.id))).toEqual(new Set([1, 2]));
+
+      expect(events.length).toBeGreaterThan(0);
+      expect(events[0]).toMatchObject({ dialect: "sqlite" });
+      expect(typeof events[0]?.durationMs).toBe("number");
+    } finally {
+      await database.close();
+    }
+  });
+});

package/src/__tests__/query-write.spec.ts

@@ -0,0 +1,293 @@
+import { describe, expect, it } from "vitest";
+import {
+  column,
+  count,
+  defineTable,
+  ensureSchema,
+  eq,
+  exists,
+  gt,
+  expr,
+  inSubquery,
+  openDatabase,
+  value,
+} from "../index.ts";
+
+const items = defineTable({
+  name: "t_items",
+  columns: {
+    f_id: { type: "serial", primaryKey: true },
+    f_key: { type: "text", notNull: true, unique: true },
+    f_count: { type: "integer", notNull: true, default: 0 },
+  },
+});
+
+const audit = defineTable({
+  name: "t_audit",
+  columns: {
+    f_item: { type: "integer", notNull: true },
+    f_note: { type: "text" },
+  },
+});
+
+describe("写入通道（RETURNING / 冲突表达式 / 子查询 / 错误分类）", () => {
+  it("insert / update 拿回行，冲突时按表达式自增", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items, audit]);
+      const table = database.table(items);
+
+      const [created] = await table.insert({ f_key: "a" }, ["f_id", "f_count"]);
+      expect(created).toMatchObject({ f_id: 1, f_count: 0 });
+
+      const [updated] = await table.update({ f_count: 10 }, eq(column("f_key"), value("a")), [
+        "f_count",
+      ]);
+      expect(updated).toMatchObject({ f_count: 10 });
+
+      // 冲突时用表达式更新：计数自增，而不是覆盖。
+      await table.upsertExpr({ f_key: "a", f_count: 1 }, ["f_key"], {
+        f_count: expr('"f_count" + 1'),
+      });
+      let afterUpsert: { count: number } | undefined;
+      for await (const row of table.select({ count: table.column("f_count") })) {
+        afterUpsert = row;
+        break;
+      }
+      expect(afterUpsert).toEqual({ count: 11 });
+    } finally {
+      await database.close();
+    }
+  });
+
+  it("子查询：IN (SELECT) 与 EXISTS", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items, audit]);
+      const table = database.table(items);
+      const auditTable = database.table(audit);
+      await table.insert({ f_key: "a" }, ["f_id"]);
+      await table.insert({ f_key: "b" }, ["f_id"]);
+      await auditTable.insertMany([{ f_item: 2, f_note: "seen" }]);
+
+      const withAudit: string[] = [];
+      for await (const row of table
+        .select({ key: table.column("f_key") })
+        .where(
+          inSubquery(
+            column("f_id"),
+            auditTable.select({ item: auditTable.column("f_item") }).toFragment(),
+          ),
+        )) {
+        withAudit.push(row.key);
+      }
+      expect(withAudit).toEqual(["b"]);
+
+      const existsRows: number[] = [];
+      for await (const row of table.select({ id: table.column("f_id") }).where(
+        exists(
+          auditTable
+            .select({ one: auditTable.column("f_item") })
+            .where(eq(column("f_item", "t_audit"), column("f_id", "t_items")))
+            .toFragment(),
+        ),
+      )) {
+        existsRows.push(row.id);
+      }
+      expect(existsRows).toEqual([2]);
+    } finally {
+      await database.close();
+    }
+  });
+
+  it("错误分类：唯一冲突与非空约束", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items]);
+      const table = database.table(items);
+      await table.insert({ f_key: "a" });
+      await expect(table.insert({ f_key: "a" })).rejects.toMatchObject({ kind: "unique" });
+      await expect(table.insert({ f_key: null as never })).rejects.toMatchObject({
+        kind: "not-null",
+      });
+    } finally {
+      await database.close();
+    }
+  });
+});
+
+describe("批量写入", () => {
+  it("insertMany + ON CONFLICT 覆盖：一行不多、值被更新", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items]);
+      const table = database.table(items);
+      await table.insertMany(
+        [
+          { f_key: "a", f_count: 1 },
+          { f_key: "b", f_count: 2 },
+        ],
+        { conflict: ["f_key"], update: ["f_count"] },
+      );
+      await table.insertMany([{ f_key: "a", f_count: 9 }], {
+        conflict: ["f_key"],
+        update: ["f_count"],
+      });
+      const rows: { key: string; count: number }[] = [];
+      for await (const row of table
+        .select({ key: table.column("f_key"), count: table.column("f_count") })
+        .orderBy("f_key")) {
+        rows.push(row);
+      }
+      expect(rows).toEqual([
+        { key: "a", count: 9 },
+        { key: "b", count: 2 },
+      ]);
+    } finally {
+      await database.close();
+    }
+  });
+});
+
+describe("事务端口（宿主管事务，执行面按调用传入）", () => {
+  it("scoped Database 用同一事务执行，回滚后什么都不留", async () => {
+    const { DatabaseSync } = await import("node:sqlite");
+    const { wrapDatabase } = await import("../index.ts");
+    const client = new DatabaseSync(":memory:");
+    const scoped = (): ReturnType<typeof wrapDatabase> =>
+      wrapDatabase("sqlite", {
+        iterate: async function* (text: string, params: readonly unknown[]) {
+          for (const row of client.prepare(text).iterate(...(params as never[]))) yield row;
+        },
+        run: async (text: string, params: readonly unknown[]) => {
+          client.prepare(text).run(...(params as never[]));
+        },
+      });
+    const database = wrapDatabase("sqlite", {
+      iterate: async function* (text: string, params: readonly unknown[]) {
+        for (const row of client.prepare(text).iterate(...(params as never[]))) yield row;
+      },
+      run: async (text: string, params: readonly unknown[]) => {
+        client.prepare(text).run(...(params as never[]));
+      },
+      transaction: async (fn) => {
+        client.exec("BEGIN IMMEDIATE");
+        try {
+          const result = await fn(scoped());
+          client.exec("COMMIT");
+          return result;
+        } catch (error) {
+          client.exec("ROLLBACK");
+          throw error;
+        }
+      },
+    });
+    try {
+      await ensureSchema(database, [items]);
+      const table = database.table(items);
+      await database.transaction(async (tx) => {
+        await tx.table(items).insert({ f_key: "a" });
+      });
+      let total = 0;
+      for await (const row of table.select({ n: count() })) total = Number(row.n);
+      expect(total).toBe(1);
+      await expect(
+        database.transaction(async (tx) => {
+          await tx.table(items).insert({ f_key: "b" });
+          throw new Error("boom");
+        }),
+      ).rejects.toThrow("boom");
+      let after = 0;
+      for await (const row of table.select({ n: count() })) after = Number(row.n);
+      expect(after).toBe(1);
+    } finally {
+      client.close();
+    }
+  });
+});
+
+describe("更新表达式", () => {
+  it("update 里可以写表达式（列自增 / 取大），普通值仍然绑定", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items]);
+      const table = database.table(items);
+      await table.insert({ f_key: "a", f_count: 1 }, ["f_id"]);
+      await table.update({ f_count: expr('"f_count" + 10') }, eq(table.f_key, "a"));
+      let seen = -1;
+      for await (const row of table.select({ count: table.f_count })) seen = row.count;
+      expect(seen).toBe(11);
+    } finally {
+      await database.close();
+    }
+  });
+});
+
+describe("删除", () => {
+  it("delete 可以拿回被删的行（RETURNING）", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items]);
+      const table = database.table(items);
+      await table.insertMany([{ f_key: "a" }, { f_key: "b" }]);
+      const removed = await table.delete(eq(table.f_key, "a"), ["f_key"]);
+      expect(removed).toEqual([{ f_key: "a" }]);
+      expect(await table.delete(eq(table.f_key, "missing"), ["f_key"])).toEqual([]);
+    } finally {
+      await database.close();
+    }
+  });
+});
+
+describe("INSERT … SELECT", () => {
+  it("按投影顺序把查询结果插进来（可带冲突子句）", async () => {
+    const archive = defineTable({
+      name: "t_archive",
+      columns: {
+        f_id: { type: "serial", primaryKey: true },
+        f_key: { type: "text", notNull: true, unique: true },
+        f_count: { type: "integer", notNull: true, default: 0 },
+      },
+    });
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items, archive]);
+      const table = database.table(items);
+      const target = database.table(archive);
+      await table.insertMany([
+        { f_key: "a", f_count: 1 },
+        { f_key: "b", f_count: 2 },
+      ]);
+      await target.insertFromSelect(
+        ["f_key", "f_count"],
+        table
+          .select({ key: table.f_key, count: table.f_count })
+          .where(gt(table.f_count, 1))
+          .toFragment(),
+      );
+      const copied: { key: string; count: number }[] = [];
+      for await (const row of target.select({ key: target.f_key, count: target.f_count })) {
+        copied.push(row);
+      }
+      expect(copied).toEqual([{ key: "b", count: 2 }]);
+    } finally {
+      await database.close();
+    }
+  });
+});
+
+describe("defineTable 即操作钩子", () => {
+  it("表定义直接拿句柄（与 database.table(def) 等价）", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, [items]);
+      const table = items.table(database);
+      await table.insert({ f_key: "hook" });
+      const seen: string[] = [];
+      for await (const row of table.select({ key: table.f_key })) seen.push(row.key);
+      expect(seen).toEqual(["hook"]);
+    } finally {
+      await database.close();
+    }
+  });
+});

package/src/__tests__/query.spec.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import {
+  and,
+  column,
+  count,
+  defineTable,
+  eq,
+  fragment,
+  inList,
+  isNull,
+  openDatabase,
+  render,
+  value,
+} from "../index.ts";
+
+const users = defineTable({
+  name: "t_users",
+  columns: {
+    f_id: { type: "serial", primaryKey: true },
+    f_name: { type: "text", notNull: true },
+    f_note: { type: "text" },
+  },
+});
+
+describe("投影查询（业务不写 SQL）", () => {
+  it("select 的投影决定结果类型，读是迭代器", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await database.run(
+        fragment(
+          'CREATE TABLE "t_users" ("f_id" INTEGER PRIMARY KEY AUTOINCREMENT, "f_name" TEXT NOT NULL, "f_note" TEXT)',
+        ),
+      );
+      const table = database.table(users);
+      await table.insert({ f_name: "ada" });
+      await table.insert({ f_name: "bob", f_note: "ops" });
+
+      const names: string[] = [];
+      for await (const row of table
+        .select({ name: table.column("f_name") })
+        .where(eq(column("f_name"), value("ada")))) {
+        names.push(row.name);
+      }
+      expect(names).toEqual(["ada"]);
+
+      await table.update({ f_note: "ops-updated" }, eq(column("f_name"), value("bob")));
+      const bob = await first(
+        table.select({ note: table.column("f_note") }).where(eq(column("f_name"), value("bob"))),
+      );
+      expect(bob).toEqual({ note: "ops-updated" });
+
+      const [total] = await collect(table.select({ n: count() }));
+      expect(total?.n).toBe(2);
+
+      await table.delete(and(eq(column("f_name"), value("ada")), isNull(column("f_note"))));
+      const [after] = await collect(table.select({ n: count() }));
+      expect(after?.n).toBe(1);
+    } finally {
+      await database.close();
+    }
+  });
+
+  it("片段是惰性迭代器：可重复消费，占位符只由参数节点生成", () => {
+    const condition = eq(column("f_name"), value("ada"));
+    expect(render(condition, "sqlite")).toEqual({ text: '"f_name" = ?', params: ["ada"] });
+    expect(render(condition, "postgres")).toEqual({ text: '"f_name" = $1', params: ["ada"] });
+    // 可重复消费：每次调用重新生成，不是一次性迭代器。
+    expect(render(condition, "sqlite")).toEqual({ text: '"f_name" = ?', params: ["ada"] });
+
+    // 多条件组合一律加括号（AND/OR 混用时优先级不靠读 SQL 的人来判断）。
+    const combined = and(condition, inList(column("f_id"), [1, 2]));
+    expect(render(combined, "postgres")).toEqual({
+      text: '("f_name" = $1 AND "f_id" IN ($2, $3))',
+      params: ["ada", 1, 2],
+    });
+  });
+});
+
+async function collect<T>(rows: AsyncIterable<T>): Promise<T[]> {
+  const result: T[] = [];
+  for await (const row of rows) result.push(row);
+  return result;
+}
+
+async function first<T>(rows: AsyncIterable<T>): Promise<T | undefined> {
+  for await (const row of rows) return row;
+  return undefined;
+}

package/src/__tests__/schema.spec.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from "vitest";
+import {
+  createDialect,
+  createTableSql,
+  defineCatalog,
+  defineTable,
+  ensureSchema,
+  fragment,
+  openDatabase,
+} from "../index.ts";
+
+const catalog = defineCatalog([
+  defineTable({
+    name: "t_items",
+    columns: {
+      f_id: { type: "serial", primaryKey: true },
+      f_owner: { type: "text", notNull: true },
+      f_count: { type: "integer", notNull: true, default: 0 },
+      f_active: { type: "boolean", notNull: true, default: 1 },
+    },
+    indexes: { idx_items_owner: { columns: ["f_owner"] } },
+  }),
+  defineTable({
+    name: "t_links",
+    columns: {
+      f_owner: {
+        type: "text",
+        notNull: true,
+        references: { table: "t_items", column: "f_owner", onDelete: "cascade" },
+      },
+      f_key: { type: "text", notNull: true },
+    },
+    primaryKey: ["f_owner", "f_key"],
+    uniques: { uq_links_key: { columns: ["f_owner", "f_key"] } },
+  }),
+]);
+
+describe("DDL 由表定义生成", () => {
+  it("SQLite 与 PostgreSQL 各自的类型 / 主键 / 引用", () => {
+    const sqlite = createDialect("sqlite");
+    const item = catalog[0]!;
+    const sqliteSql = createTableSql(sqlite, item);
+    expect(sqliteSql).toContain('"f_id" INTEGER PRIMARY KEY AUTOINCREMENT');
+    expect(sqliteSql).toContain('"f_active" INTEGER NOT NULL DEFAULT 1');
+    expect(sqliteSql).toContain('CREATE TABLE IF NOT EXISTS "t_items"');
+
+    const postgres = createDialect("postgres");
+    const postgresSql = createTableSql(postgres, item);
+    expect(postgresSql).toContain('"f_id" SERIAL PRIMARY KEY');
+    expect(postgresSql).toContain('"f_active" BOOLEAN NOT NULL DEFAULT TRUE');
+    expect(postgresSql).toContain('CREATE TABLE IF NOT EXISTS "public"."t_items"');
+
+    const link = catalog[1]!;
+    expect(createTableSql(sqlite, link)).toContain(
+      'REFERENCES "t_items"("f_owner") ON DELETE CASCADE',
+    );
+    expect(createTableSql(sqlite, link)).toContain('PRIMARY KEY ("f_owner", "f_key")');
+  });
+});
+
+describe("ensureSchema 只做增", () => {
+  it("建表、补列、补索引，并且重复执行是幂等的", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      const first = await ensureSchema(database, catalog);
+      expect(first.some((sql) => sql.startsWith('CREATE TABLE IF NOT EXISTS "t_items"'))).toBe(
+        true,
+      );
+
+      // 第二次：结构已对齐，不再执行任何语句。
+      expect(await ensureSchema(database, catalog)).toEqual([]);
+
+      // 定义里多一列：只在旧表上补这一列。
+      const extended = defineCatalog([
+        defineTable({
+          ...catalog[0]!,
+          columns: { ...catalog[0]!.columns, f_note: { type: "text" } },
+        }),
+        catalog[1]!,
+      ]);
+      const applied = await ensureSchema(database, extended);
+      expect(applied).toEqual(['ALTER TABLE "t_items" ADD COLUMN "f_note" TEXT']);
+
+      const columns = await database.read<{ name: string }>(
+        fragment('PRAGMA table_info("t_items")'),
+      );
+      expect(columns.map((row) => row.name)).toContain("f_note");
+    } finally {
+      await database.close();
+    }
+  });
+
+  it("已有数据的表加 NOT NULL 列（无默认值）时 fail loud", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, catalog);
+      const strict = defineCatalog([
+        defineTable({
+          ...catalog[0]!,
+          columns: { ...catalog[0]!.columns, f_note: { type: "text", notNull: true } },
+        }),
+      ]);
+      await expect(ensureSchema(database, strict)).rejects.toThrow(/without a default/u);
+    } finally {
+      await database.close();
+    }
+  });
+
+  it("catalog 注入后按表名取表；允许破坏性变更时才删多余列", async () => {
+    const database = await openDatabase({ dialect: "sqlite", path: ":memory:" });
+    try {
+      await ensureSchema(database, catalog);
+      // 定义里没有 f_legacy：默认保留（升级不丢数据）。
+      await database.run(fragment('ALTER TABLE "t_items" ADD COLUMN "f_legacy" TEXT'));
+      expect(await ensureSchema(database, catalog)).toEqual([]);
+      const dropped = await ensureSchema(database, catalog, { allowDestructive: true });
+      expect(dropped).toEqual(['ALTER TABLE "t_items" DROP COLUMN "f_legacy"']);
+    } finally {
+      await database.close();
+    }
+  });
+});
+
+describe("SQLite 连接调优选项", () => {
+  it("cacheSizeKb / mmapSize 落到 PRAGMA（连接级，从同一连接读回）", async () => {
+    const { openDatabase } = await import("../index.ts");
+    const { fragment } = await import("../index.ts");
+    const path = `/tmp/rdbkit-pragma-${Date.now()}.sqlite`;
+    const database = await openDatabase({
+      dialect: "sqlite",
+      path,
+      cacheSizeKb: 65536,
+      mmapSize: 268435456,
+    });
+    try {
+      const [cache] = await database.read<{ cache_size: number }>(fragment("PRAGMA cache_size"));
+      const [mmap] = await database.read<{ mmap_size: number }>(fragment("PRAGMA mmap_size"));
+      expect(cache?.cache_size).toBe(-65536);
+      expect(mmap?.mmap_size).toBe(268435456);
+    } finally {
+      await database.close();
+    }
+  });
+});