@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/StatementMappers.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it } from "vitest";
+import { DictionaryMapper } from "./mappers/DictionaryMapper.ts";
+import { StatementMappers } from "./StatementMappers.ts";
+import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.ts";
+import { DeleteStatement } from "./statements/DeleteStatement.ts";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
+import { Identifier } from "./statements/Identifier.ts";
+import { InsertStatement } from "./statements/InsertStatement.ts";
+import { Join } from "./statements/Join.ts";
+import { Operator } from "./statements/Operator.ts";
+import { OrderBy } from "./statements/OrderBy.ts";
+import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.ts";
+import { SelectStatement } from "./statements/SelectStatement.ts";
+import { UpdateStatement } from "./statements/UpdateStatement.ts";
+import { Where } from "./statements/Where.ts";
+import { WhereText } from "./statements/WhereText.ts";
+import type { Cell } from "./converters/Cell.ts";
+
+const mapper = (name: string, value: Cell): Cell =>
+  typeof value === "string" ? `${name}:${value.toUpperCase()}` : value;
+
+describe("StatementMappers", () => {
+  it("maps a select", () => {
+    const mappings = new StatementMappers(
+      new DictionaryMapper([
+        ["User", "people"],
+        ["Role", "roles"],
+      ]),
+      new DictionaryMapper([
+        ["Name", "full_name"],
+        ["title", "book.title"],
+        ["id", "user_id"],
+      ]),
+    );
+    const select = new SelectStatement({
+      distinct: true,
+      table: "User",
+      fields: ["Name", "title", "scope.title", "alias.other", '"schema.name".id'],
+      where: new Where(new Operator.Equals("Name", "Bea")),
+      joins: [Join.inner("Role", "User.id", "Role.user_id"), Join.cross("logs")],
+      groupBy: ["Name"],
+      having: new Where(new Operator.Equals("Name", "Bea")),
+      orderBy: [OrderBy.desc("Name")],
+      limit: 5,
+      offset: 1,
+    });
+    const mapped = mappings.apply(select, mapper) as SelectStatement;
+    expect(mapped.table).toBe("people");
+    expect(mapped.fields).toEqual([
+      "full_name",
+      "book.title",
+      "book.title",
+      "alias.other",
+      '"schema.name".user_id',
+    ]);
+    expect(mapped.distinct).toBe(true);
+    expect(mapped.limit).toBe(5);
+    expect(mapped.offset).toBe(1);
+    expect(mapped.groupBy).toEqual(["full_name"]);
+    expect(mapped.orderBy).toEqual([{ column: "full_name", direction: "desc" }]);
+    expect((mapped.joins[0]?.on as Operator.Equals).left).toBeInstanceOf(Identifier);
+    expect(((mapped.joins[0]?.on as Operator.Equals).left as Identifier).name).toBe("people.user_id");
+    expect(mapped.joins[1]).toEqual({ kind: "cross", table: "logs" });
+    expect(DefaultStatementTextRenderer.instance.render(mapped)).toContain("full_name = $full_name");
+    expect(mapped.where?.parameters?.[0]?.value).toBe("Name:BEA");
+    expect(mappings.property("full_name")).toBe("Name");
+    expect(mappings.property("people.full_name")).toBe("Name");
+    expect(mappings.property("other")).toBe("other");
+    expect(mappings.property("people.missing")).toBe("people.missing");
+  });
+
+  it("maps writes", () => {
+    const mappings = new StatementMappers(
+      new DictionaryMapper([
+        ["User", "people"],
+        ["Role", "roles"],
+      ]),
+      new DictionaryMapper([
+        ["Name", "full_name"],
+        ["title", "book.title"],
+        ["id", "user_id"],
+      ]),
+    );
+    const insert = mappings.apply(new InsertStatement("User", [{ name: "Name", value: "Ada" }]), mapper) as InsertStatement;
+    expect(DefaultStatementTextRenderer.instance.render(insert)).toBe("INSERT INTO people (full_name) VALUES ($full_name)");
+    expect(insert.fields[0]?.value).toBe("Ada");
+
+    const update = mappings.apply(
+      new UpdateStatement("User", [{ name: "Name", value: "Ada" }], new Where(new Operator.Equals("Name", "Bea"))),
+      mapper,
+    ) as UpdateStatement;
+    expect(DefaultStatementTextRenderer.instance.render(update)).toBe(
+      "UPDATE people SET full_name = $full_name WHERE full_name = $full_name__where",
+    );
+    expect(update.parameters[0]?.value).toBe("Ada");
+    expect(update.parameters[1]).toEqual({ name: "full_name__where", value: "Name:BEA" });
+
+    const deleted = mappings.apply(
+      new DeleteStatement("User", new Where(new Operator.Equals("Name", "Bea"))),
+      mapper,
+    ) as DeleteStatement;
+    expect(DefaultStatementTextRenderer.instance.render(deleted)).toBe("DELETE FROM people WHERE full_name = $full_name");
+
+    const inserted = mappings.apply(new SelectInsertedIdStatement("User", "id"), mapper) as SelectInsertedIdStatement;
+    expect(inserted.table).toBe("people");
+    expect(inserted.column).toBe("user_id");
+  });
+
+  it("leaves raw and other statements", () => {
+    const mappings = new StatementMappers(
+      new DictionaryMapper([
+        ["User", "people"],
+        ["Role", "roles"],
+      ]),
+      new DictionaryMapper([
+        ["Name", "full_name"],
+        ["title", "book.title"],
+        ["id", "user_id"],
+      ]),
+    );
+    const call = new ExecuteStoredProcedureStatement("save_user", []);
+    expect(mappings.apply(call, mapper)).toBe(call);
+    expect(mappings.apply(undefined, mapper)).toBeUndefined();
+    const text = new WhereText("name = $name");
+    expect(mappings.applyWhere(text, mapper)).toBe(text);
+    const kept = mappings.apply(new DeleteStatement("User", text), mapper) as DeleteStatement;
+    expect(kept.where).toBe(text);
+    expect(DefaultStatementTextRenderer.instance.render(kept)).toBe("DELETE FROM people WHERE name = $name");
+  });
+
+  it("maps a select field alias", () => {
+    const mappings = new StatementMappers(
+      new DictionaryMapper([
+        ["Contact", "contacts_base"],
+        ["Address", "address"],
+      ]),
+      new DictionaryMapper([
+        ["Id", "id"],
+        ["FirstName", "first_name"],
+        ["ContactId", "contact_id"],
+      ]),
+    );
+    const select = new SelectStatement({
+      table: "Contact",
+      fields: ["Contact.Id AS Id", "Contact.FirstName AS FirstName", "Address.Id AS AddressId"],
+      joins: [Join.left("Address", "Contact.Id", "Address.ContactId")],
+    });
+    const mapped = mappings.apply(select, mapper) as SelectStatement;
+    expect(DefaultStatementTextRenderer.instance.render(mapped)).toBe(
+      "SELECT contacts_base.id AS Id, contacts_base.first_name AS FirstName, address.id AS AddressId FROM contacts_base LEFT JOIN address ON contacts_base.id = address.contact_id",
+    );
+  });
+
+  it("maps a contacts select", () => {
+    const mappings = new StatementMappers(
+      new DictionaryMapper([
+        ["Contact", "contacts_base"],
+        ["ContactSource", "contact_source"],
+        ["ContactType", "contact_type"],
+        ["Address", "address"],
+        ["AddressType", "address_type"],
+        ["Phone", "phone"],
+        ["PhoneType", "phone_type"],
+      ]),
+      new DictionaryMapper([
+        ["Id", "id"],
+        ["FirstName", "first_name"],
+        ["LastName", "last_name"],
+        ["Email", "email"],
+        ["Name", "name"],
+        ["Line1", "line1"],
+        ["City", "city"],
+        ["Number", "number"],
+        ["ContactId", "contact_id"],
+        ["ContactSourceId", "contact_source_id"],
+        ["ContactTypeId", "contact_type_id"],
+        ["AddressTypeId", "address_type_id"],
+        ["PhoneTypeId", "phone_type_id"],
+      ]),
+    );
+    const select = new SelectStatement({
+      distinct: true,
+      table: "Contact",
+      fields: [
+        "Contact.FirstName",
+        "Contact.LastName",
+        "Contact.Email",
+        "ContactSource.Name",
+        "Address.Line1",
+        "Address.City",
+        "Phone.Number",
+      ],
+      where: new Where(
+        new Operator.And(
+          new Operator.Equals("Contact.Email", "ada@ex.com"),
+          new Operator.GreaterThan("Address.City", "A"),
+        ),
+      ),
+      joins: [
+        Join.inner("ContactSource", "Contact.ContactSourceId", "ContactSource.Id"),
+        Join.inner("ContactType", "Contact.ContactTypeId", "ContactType.Id"),
+        Join.left("Address", "Contact.Id", "Address.ContactId"),
+        Join.left("AddressType", "Address.AddressTypeId", "AddressType.Id"),
+        Join.left("Phone", "Contact.Id", "Phone.ContactId"),
+        Join.left("PhoneType", "Phone.PhoneTypeId", "PhoneType.Id"),
+      ],
+      groupBy: ["Contact.LastName"],
+      having: new Where(new Operator.Equals("ContactType.Name", "person")),
+      orderBy: [OrderBy.asc("Contact.LastName"), OrderBy.desc("Contact.FirstName")],
+      limit: 20,
+      offset: 1,
+    });
+    const mapped = mappings.apply(select, mapper) as SelectStatement;
+    expect(DefaultStatementTextRenderer.instance.render(mapped)).toBe(
+      "SELECT DISTINCT contacts_base.first_name, contacts_base.last_name, contacts_base.email, contact_source.name, address.line1, address.city, phone.number FROM contacts_base INNER JOIN contact_source ON contacts_base.contact_source_id = contact_source.id INNER JOIN contact_type ON contacts_base.contact_type_id = contact_type.id LEFT JOIN address ON contacts_base.id = address.contact_id LEFT JOIN address_type ON address.address_type_id = address_type.id LEFT JOIN phone ON contacts_base.id = phone.contact_id LEFT JOIN phone_type ON phone.phone_type_id = phone_type.id WHERE contacts_base.email = $contacts_base.email AND address.city > $address.city GROUP BY contacts_base.last_name HAVING contact_type.name = $contact_type.name ORDER BY contacts_base.last_name ASC, contacts_base.first_name DESC LIMIT 20 OFFSET 1",
+    );
+    expect(mapped.where?.parameters[0]?.value).toBe("Contact.Email:ADA@EX.COM");
+    expect(mapped.where?.parameters[1]?.value).toBe("Address.City:A");
+    expect((mapped.having as Where).parameters[0]?.value).toBe("ContactType.Name:PERSON");
+  });
+});

package/src/StatementMappers.ts

@@ -0,0 +1,110 @@
+import type { Cell } from "./converters/Cell.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+import { DeleteStatement } from "./statements/DeleteStatement.ts";
+import type { IStatement } from "./statements/IStatement.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import { InsertStatement } from "./statements/InsertStatement.ts";
+import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.ts";
+import { SelectStatement } from "./statements/SelectStatement.ts";
+import { UpdateStatement } from "./statements/UpdateStatement.ts";
+import { Where } from "./statements/Where.ts";
+
+export class StatementMappers implements IMapper<string, string> {
+  constructor(
+    private readonly entityMappers: IMapper<string, string>,
+    private readonly propertyMappers: IMapper<string, string>,
+  ) {}
+
+  map = (property: string): string => {
+    const dot = lastDot(property);
+    if (dot < 0) return this.propertyMappers.map(property);
+    const qualifier = property.slice(0, dot);
+    const name = property.slice(dot + 1);
+    const mapped = this.propertyMappers.map(name);
+    if (mapped !== name && mapped.includes(".")) return mapped;
+    const table = this.entityMappers.map(qualifier);
+    return table === qualifier && mapped === name ? property : `${table}.${mapped}`;
+  };
+
+  reverseMap = (key: string): string => {
+    const reversed = this.propertyMappers.reverseMap(key);
+    if (reversed !== key && this.propertyMappers.map(reversed) === key) return reversed;
+    const dot = lastDot(key);
+    if (dot < 0) return reversed;
+    const column = key.slice(dot + 1);
+    const name = this.propertyMappers.reverseMap(column);
+    return name !== column && this.propertyMappers.map(name) === column ? name : reversed;
+  };
+
+  column = (property: string): string => this.map(property);
+
+  property = (key: string): string => this.reverseMap(key);
+
+  apply = (
+    query: IStatement | undefined,
+    cell: (property: string, value: Cell) => Cell,
+  ): IStatement | undefined => {
+    if (query instanceof SelectStatement && query.table)
+      return new SelectStatement({
+        distinct: query.distinct,
+        table: this.entityMappers.map(query.table),
+        fields: query.fields.map(this.mapSelectField),
+        where: query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
+        joins: query.joins.map((join) => ({
+          kind: join.kind,
+          table: this.entityMappers.map(join.table),
+          on: join.on ? new Where(join.on).map(this.column, cell).condition : undefined,
+        })),
+        groupBy: query.groupBy.map(this.column),
+        having: query.having instanceof Where ? this.applyWhere(query.having, cell) : query.having,
+        orderBy: query.orderBy.map((order) => ({ column: this.column(order.column), direction: order.direction })),
+        limit: query.limit,
+        offset: query.offset,
+      });
+    if (query instanceof InsertStatement && query.table !== undefined)
+      return new InsertStatement(
+        this.entityMappers.map(query.table),
+        query.fields.map((field) => ({ name: this.column(field.name), value: field.value })),
+      );
+    if (query instanceof UpdateStatement && query.table !== undefined)
+      return new UpdateStatement(
+        this.entityMappers.map(query.table),
+        query.fields.map((field) => ({ name: this.column(field.name), value: field.value })),
+        query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
+      );
+    if (query instanceof DeleteStatement && query.table !== undefined)
+      return new DeleteStatement(
+        this.entityMappers.map(query.table),
+        query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
+      );
+    if (query instanceof SelectInsertedIdStatement)
+      return new SelectInsertedIdStatement(this.entityMappers.map(query.table), this.column(query.column));
+    return query;
+  };
+
+  applyWhere = (
+    where: IWhere | undefined,
+    cell: (property: string, value: Cell) => Cell,
+  ): IWhere | undefined =>
+    where instanceof Where ? where.map(this.column, cell) : where;
+
+  private mapSelectField = (field: string): string => {
+    const asIndex = field.toUpperCase().indexOf(" AS ");
+    if (asIndex >= 0) {
+      const expression = field.slice(0, asIndex).trim();
+      const alias = field.slice(asIndex + 4).trim();
+      return `${this.map(expression)} AS ${alias}`;
+    }
+    return this.map(field);
+  };
+}
+
+const lastDot = (name: string): number => {
+  let quoted = false;
+  let dot = -1;
+  for (let i = 0; i < name.length; i++) {
+    if (name[i] === '"') quoted = !quoted;
+    if (name[i] === "." && !quoted) dot = i;
+  }
+  return dot;
+};

package/src/StoredEnrichment.ts

@@ -0,0 +1,25 @@
+import type { Enrichment } from "./Enrichment.ts";
+import type { ICRUDRepository } from "./ICRUDRepository.ts";
+import type { Row } from "./Row.ts";
+
+export type ApplyEnrichment<T extends object = object> = (
+  parents: T[],
+  sources?: (Row | undefined)[],
+) => Promise<void>;
+
+export class StoredEnrichment<T extends object = object> {
+  apply: ApplyEnrichment<T>;
+  persist?: ICRUDRepository<object>;
+  link?: ICRUDRepository<object>;
+
+  constructor(
+    readonly enrichment: Enrichment,
+    apply: ApplyEnrichment<T>,
+    persist?: ICRUDRepository<object>,
+    link?: ICRUDRepository<object>,
+  ) {
+    this.apply = apply;
+    this.persist = persist;
+    this.link = link;
+  }
+}

package/src/StoredProcedureBulkWriteStrategy.ts

@@ -0,0 +1,164 @@
+import type { Cell, Cells } from "./converters/Cell.ts";
+import { DatasourceError } from "./DatasourceError.ts";
+import type { Response } from "./Response.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
+import type { CRUDRepository } from "./CRUDRepository.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+import type { ICommand } from "./ICommand.ts";
+import { execute } from "./ICommand.ts";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
+import { repositoryParts } from "./CRUDRepositoryBuilder.ts";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+import { afterBulkWrite } from "./BulkWriteEnrichment.ts";
+import { ParameterDirection } from "./ParameterDirection.ts";
+import type { Parameter } from "./Parameter.ts";
+
+const empty = (): Response => ({ result: null, rowsAffected: 0 });
+
+const json = (rows: Cells[]): string => `[${rows.map(object).join(",")}]`;
+
+const object = (row: Cells): string =>
+  `{${Object.entries(row)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${quote(key)}:${scalar(value)}`)
+    .join(",")}}`;
+
+const scalar = (value: Cell): string => {
+  if (value === null || value === undefined) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : fail();
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "string") return quote(value);
+  if (value instanceof Date) return quote(roundTrip(value));
+  if (value instanceof Uint8Array) return quote(base64(value));
+  return fail();
+};
+
+const fail = (): string => {
+  throw new DatasourceError("Unsupported bulk payload value");
+};
+
+const roundTrip = (date: Date): string =>
+  date.toISOString().replace(/\.(\d{3})Z$/, (_, fraction: string) => `.${fraction}0000Z`);
+
+const base64 = (bytes: Uint8Array): string =>
+  btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""));
+
+const quote = (text: string): string => {
+  let result = "\"";
+  for (const ch of text) {
+    result += ({
+      "\\": "\\\\",
+      "\"": "\\\"",
+      "\b": "\\b",
+      "\f": "\\f",
+      "\n": "\\n",
+      "\r": "\\r",
+      "\t": "\\t",
+    }[ch] ?? (ch < " " ? `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}` : ch));
+  }
+  return `${result}"`;
+};
+
+export class StoredProcedureBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
+  repo!: CRUDRepository<T>;
+  command!: ICommand;
+  options!: CRUDRepositoryOptions<T>;
+
+  attach = (command: ICommand, options: CRUDRepositoryOptions<T>): void => {
+    this.command = command;
+    this.options = options;
+  };
+
+  constructor(
+    private readonly createName: string,
+    private readonly updateName: string,
+    private readonly deleteName: string,
+  ) {}
+
+  create = (items: T[]): Promise<Response> => this.then(this.call(this.createName, items, true), items, "create");
+
+  update = (items: T[], _byWhere: IWhere | undefined): Promise<Response> =>
+    this.then(this.call(this.updateName, items), items, "update");
+
+  delete = (items: T[], _byWhere: IWhere | undefined): Promise<Response> =>
+    this.then(this.call(this.deleteName, items), items, "delete");
+
+  private then = async (write: Promise<Response>, items: T[], mode: "create" | "update" | "delete"): Promise<Response> => {
+    const response = await write;
+    await afterBulkWrite(this.repo, this.options, items, mode);
+    return response;
+  };
+
+  private call = async (name: string, items: T[], generated = false): Promise<Response> => {
+    if (items.length === 0) return empty();
+    const payload = { name: "payload", value: json(items.map((item) => this.rowOf(item, generated))) };
+      const parameters: Parameter[] = generated && this.ids().length === 1
+      ? [payload, { name: "ids", value: null, direction: ParameterDirection.InputOutput }]
+      : [payload];
+    const response = await execute(this.command, new ExecuteStoredProcedureStatement(name, parameters), parameters);
+    if (generated) this.applyIds(items, response.parameters);
+    return response;
+  };
+
+  private ids = (): readonly string[] => this.options.ids ?? this.repo.ids ?? ["id"];
+
+  private rowOf = (item: T, create = false): Cells => {
+    const stored = this.reverse(item);
+    const statements = repositoryParts(this.command.connection, this.options).statements;
+    const row: Cells = {};
+    for (const name of statements.readColumns) {
+      if (create && this.identity(name) && !assigned(stored[name] ?? stored[this.ids()[0]!])) continue;
+      const match = Object.entries(stored).find(([key]) => this.column(key) === name);
+      row[name] = match?.[1] ?? null;
+    }
+    return row;
+  };
+
+  private identity = (column: string): boolean => this.ids().length === 1 && this.ids()[0] === column;
+
+  private applyIds = (items: T[], parameters?: Parameter[]): void => {
+    if (this.ids().length !== 1) return;
+    const found = parameters?.find((parameter) => parameter.name === "ids");
+    const list = parseIds(found?.value);
+    const column = this.ids()[0]!;
+    for (let index = 0; index < items.length && index < list.length; index++)
+      stamp(items[index], column, list[index]!);
+  };
+
+  private column = (property: string): string => this.options.propertyMappings?.map(property) ?? property;
+
+  private reverse = (item: T): Cells => {
+    const objects = this.options.objectConverter ?? new MetaDataRowTypeConverter<T>();
+    const row = objects.reverseConvert(item);
+    return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
+  };
+}
+
+const assigned = (value: Cell | undefined): boolean => {
+  if (value === null || value === undefined) return false;
+  if (value === 0 || value === 0n) return false;
+  if (typeof value === "string") return value.length > 0;
+  return true;
+};
+
+const parseIds = (value: Cell | undefined): number[] => {
+  const text =
+    typeof value === "string" ? value.trim()
+    : typeof value === "number" || typeof value === "bigint" ? String(value)
+    : "";
+  if (text === "" || text === "[]" || text === "null") return [];
+  return text
+    .replace(/^\[/, "")
+    .replace(/\]$/, "")
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => Number(part));
+};
+
+const stamp = <T extends object>(item: T, column: string, id: number): void => {
+  const key = column in item ? column : "id" in item ? "id" : "Id" in item ? "Id" : column;
+  (item as Record<string, Cell>)[key] = id;
+};

package/src/StreamingReader.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { splitStatements, statementParameters, statementUsesParameter, statementReader, StreamingReader } from "./index.ts";
+
+describe("splitStatements", () => {
+  it("splits on semicolons outside quotes and comments", () => {
+    expect(splitStatements("")).toEqual([]);
+    expect(splitStatements("SELECT 1")).toEqual(["SELECT 1"]);
+    expect(splitStatements("SELECT 1;")).toEqual(["SELECT 1"]);
+    expect(splitStatements("SELECT 1 AS id; SELECT 2 AS id")).toEqual([
+      "SELECT 1 AS id",
+      "SELECT 2 AS id",
+    ]);
+    expect(splitStatements("SELECT ';' AS id; SELECT 2 AS id")).toEqual([
+      "SELECT ';' AS id",
+      "SELECT 2 AS id",
+    ]);
+    expect(splitStatements('SELECT "a""b" AS id; SELECT `c`')).toEqual([
+      'SELECT "a""b" AS id',
+      "SELECT `c`",
+    ]);
+    expect(splitStatements("SELECT 1; -- tail\nSELECT 2")).toEqual([
+      "SELECT 1",
+      "-- tail\nSELECT 2",
+    ]);
+    expect(splitStatements("SELECT 1; /* ; */ SELECT 2")).toEqual([
+      "SELECT 1",
+      "/* ; */ SELECT 2",
+    ]);
+    const mysql = "CREATE PROCEDURE add_user()\nBEGIN\n  INSERT INTO t VALUES (1);\nEND";
+    expect(splitStatements(mysql)).toEqual([mysql]);
+    const postgres =
+      "CREATE PROCEDURE bulk_create_user(payload jsonb)\nLANGUAGE plpgsql\nAS $$\nBEGIN\n  INSERT INTO t VALUES (1);\nEND;\n$$";
+    expect(splitStatements(postgres)).toEqual([postgres]);
+  });
+
+  it("matches a parameter token at a word boundary", () => {
+    expect(statementUsesParameter("INSERT INTO t (is_enabled) VALUES ($is_enabled__10)", "is_enabled__10")).toBe(true);
+    expect(statementUsesParameter("INSERT INTO t (is_enabled) VALUES ($is_enabled__10)", "is_enabled__1")).toBe(false);
+    expect(statementUsesParameter("$is_enabled__1", "is_enabled__1")).toBe(true);
+    expect(statementParameters("INSERT INTO t (a, b) VALUES ($a__0, $b__0), ($a__1, $b__1)")).toEqual([
+      "a__0",
+      "b__0",
+      "a__1",
+      "b__1",
+    ]);
+  });
+});
+
+describe("StreamingReader", () => {
+  it("reads the current set and advances on nextResult", async () => {
+    const sets = [[{ id: 1 }], [{ id: 2 }]];
+    let set = 0;
+    let row = 0;
+    let reads = 0;
+    let closed = false;
+    const reader = new StreamingReader(
+      async () => {
+        reads += 1;
+        const rows = sets[set] ?? [];
+        if (row >= rows.length) return undefined;
+        const current = rows[row];
+        row += 1;
+        return current;
+      },
+      async () => {
+        set += 1;
+        row = 0;
+        return set < sets.length;
+      },
+      async () => {
+        closed = true;
+      },
+    );
+    expect(reads).toBe(0);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 1 });
+    expect(await reader.next()).toBe(false);
+    expect(reader.current).toBeUndefined();
+    expect(await reader.nextResult()).toBe(true);
+    expect(reader.current).toBeUndefined();
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 2 });
+    expect(await reader.nextResult()).toBe(false);
+    await reader.dispose();
+    await reader.dispose();
+    expect(closed).toBe(true);
+    const plain = new StreamingReader(
+      async () => undefined,
+      async () => false,
+    );
+    expect(await Array.fromAsync(plain.read())).toEqual([]);
+    await plain.dispose();
+    await plain[Symbol.asyncDispose]();
+    await plain.dispose();
+  });
+
+  it("loads one statement at a time", async () => {
+    const loaded: string[] = [];
+    const reader = statementReader(["SELECT 1 AS id", "SELECT 2 AS id"], async function* (sql) {
+      loaded.push(sql);
+      yield sql.endsWith("1 AS id") ? { id: 1 } : { id: 2 };
+    });
+    expect(loaded).toEqual([]);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 1 });
+    expect(await reader.next()).toBe(false);
+    expect(loaded).toEqual(["SELECT 1 AS id"]);
+    expect(await reader.nextResult()).toBe(true);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 2 });
+    expect(await reader.nextResult()).toBe(false);
+    expect(await reader.next()).toBe(false);
+    expect(loaded).toEqual(["SELECT 1 AS id", "SELECT 2 AS id"]);
+    await reader.dispose();
+  });
+
+  it("returns false when a statement reader has no statements", async () => {
+    const reader = statementReader([], async function* () {});
+    expect(await reader.next()).toBe(false);
+    expect(await reader.nextResult()).toBe(false);
+    const blank = statementReader([""], async function* () {
+      yield { id: 1 };
+    });
+    expect(await blank.next()).toBe(false);
+  });
+});