@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/statements/StatementEvaluator.ts

@@ -0,0 +1,5 @@
+import type { IStatement } from "./IStatement.ts";
+
+export class StatementEvaluator {
+  evaluate = (_statement: IStatement): void => {};
+}

package/src/statements/StatementParser.test.ts

@@ -0,0 +1,304 @@
+import { describe, expect, it } from "vitest";
+import {
+  ArrayExpression,
+  DeleteStatement,
+  Identifier,
+  InsertStatement,
+  Join,
+  Literal,
+  Operator,
+  SelectStatement,
+  ExpressionEvaluator,
+  StatementParser,
+  Subquery,
+  UpdateStatement,
+  Where,
+  DefaultStatementTextRenderer,
+} from "../index.ts";
+import type { IExpression } from "./IExpression.ts";
+
+const roundTrip = (sql: string): void => {
+  expect(DefaultStatementTextRenderer.instance.render(StatementParser.parse(sql))).toBe(sql);
+};
+
+describe("StatementParser", () => {
+  it("round-trips the select grammar", () => {
+    for (const sql of [
+      "SELECT id FROM users WHERE name NOT LIKE $name",
+      "SELECT id FROM users WHERE age NOT BETWEEN $age_0 AND $age_1",
+      "SELECT DISTINCT status FROM orders GROUP BY status HAVING status = $status ORDER BY status ASC LIMIT 10 OFFSET 5",
+      'SELECT "user".id AS user_id FROM "user"',
+      "SELECT id FROM users WHERE 'a' = 'b'",
+      "SELECT id FROM users FULL JOIN profiles ON users.id = profiles.user_id AND profiles.active = $profiles.active",
+      "SELECT id FROM users WHERE EXISTS (SELECT id FROM posts WHERE posts.user_id = users.id)",
+      "SELECT id FROM users CROSS JOIN tags",
+      "SELECT id FROM users WHERE id IS NULL",
+      "SELECT id FROM users WHERE id IS NOT NULL",
+      "SELECT id FROM users WHERE name LIKE $name",
+      "SELECT id FROM users WHERE id IN ($id_0, $id_1)",
+      "SELECT id FROM users WHERE id NOT IN ($id_0)",
+      "SELECT id FROM users WHERE age BETWEEN $age_0 AND $age_1",
+      "SELECT id FROM users WHERE 1 = 0",
+      "SELECT id, name FROM users WHERE id = $id AND age > $age",
+      "SELECT status, COUNT(*) AS n, SUM(amount) AS total FROM orders INNER JOIN customers ON orders.customer_id = customers.id WHERE status = $status GROUP BY status ORDER BY total DESC, status ASC LIMIT 10",
+    ])
+      roundTrip(sql);
+  });
+
+  it("round-trips the write grammar", () => {
+    for (const sql of [
+      "INSERT INTO users (id, name) VALUES ($id, $name)",
+      'INSERT INTO "user" (id) VALUES ($id)',
+      "UPDATE users SET name = $name WHERE id = $id",
+      "UPDATE users SET name = $name, age = $age",
+      "UPDATE users SET name = $name WHERE name NOT LIKE $name",
+      "DELETE FROM users WHERE id = $id",
+      "DELETE FROM users",
+      'DELETE FROM "user" WHERE id = $id',
+      "DELETE FROM users WHERE name NOT LIKE $name",
+    ])
+      roundTrip(sql);
+  });
+
+  it("builds the write trees", () => {
+    expect(StatementParser.parse("INSERT INTO users (id, name) VALUES ($id, $name)")).toBeInstanceOf(
+      InsertStatement,
+    );
+    const update = StatementParser.parse("UPDATE users SET name = $name WHERE id = $id") as UpdateStatement;
+    expect((update.where as Where).condition).toBeInstanceOf(Operator.Equals);
+    const notLike = StatementParser.parse(
+      "UPDATE users SET name = $name WHERE name NOT LIKE $name",
+    ) as UpdateStatement;
+    expect((notLike.where as Where).condition).toBeInstanceOf(Operator.NotLike);
+    const deleted = StatementParser.parse("DELETE FROM users WHERE id = $id") as DeleteStatement;
+    expect((deleted.where as Where).condition).toBeInstanceOf(Operator.Equals);
+    expect((StatementParser.parse("DELETE FROM users") as DeleteStatement).where).toBeUndefined();
+    expect(() => StatementParser.parse("INSERT INTO users (name) VALUES ('ada')")).toThrow("empty statement");
+    expect(() => StatementParser.parse("UPDATE users SET name = name WHERE id = $id")).toThrow("empty statement");
+  });
+
+  it("builds the where tree", () => {
+    const notLike = StatementParser.parse("SELECT id FROM users WHERE name NOT LIKE $name") as SelectStatement;
+    expect((notLike.where as Where).condition).toBeInstanceOf(Operator.NotLike);
+
+    const exists = StatementParser.parse(
+      "SELECT id FROM users WHERE EXISTS (SELECT id FROM posts WHERE posts.user_id = users.id)",
+    ) as SelectStatement;
+    expect((exists.where as Where).condition).toBeInstanceOf(Operator.Exists);
+
+    const full = StatementParser.parse(
+      "SELECT id FROM users FULL JOIN profiles ON users.id = profiles.user_id",
+    ) as SelectStatement;
+    expect(full.joins[0]?.kind).toBe("full");
+
+    const cross = StatementParser.parse("SELECT id FROM users CROSS JOIN tags") as SelectStatement;
+    expect(cross.joins[0]?.kind).toBe("cross");
+    expect(cross.joins[0]?.on).toBeUndefined();
+
+    const shaped = StatementParser.parse(
+      "SELECT DISTINCT status FROM orders GROUP BY status HAVING status = $status ORDER BY status ASC LIMIT 10 OFFSET 5",
+    ) as SelectStatement;
+    expect(shaped.distinct).toBe(true);
+    expect(shaped.limit).toBe(10);
+    expect(shaped.offset).toBe(5);
+    expect((shaped.having as Where).condition).toBeInstanceOf(Operator.Equals);
+  });
+
+  it("keeps a string beside a column as its parameter", () => {
+    const query = StatementParser.parse("SELECT id FROM users WHERE name = 'ada'") as SelectStatement;
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe("SELECT id FROM users WHERE name = $name");
+    expect(query.where?.parameters).toEqual([{ name: "name", value: "ada" }]);
+  });
+
+  it("evaluates the new predicates", () => {
+    const row = { name: "ada", age: 30, id: null };
+    const evaluator = new ExpressionEvaluator();
+    expect(evaluator.evaluate(new Operator.IsNull(new Identifier("id")), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.Like("name", "a%"), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.NotLike("name", "a%"), row)).toBe(false);
+    expect(evaluator.evaluate(new Operator.Between("age", 18, 40), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.NotBetween("age", 18, 40), row)).toBe(false);
+    expect(evaluator.evaluate(new Operator.NotIn("age", [1, 2]), row)).toBe(true);
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.NotLike("name", "%a")))).toBe("name NOT LIKE $name");
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.NotBetween("age", 1, 2)))).toBe(
+      "age NOT BETWEEN $age_0 AND $age_1",
+    );
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.NotIn("id", [])))).toBe("1 = 1");
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Not(new Operator.Like("name", "%a"))))).toBe(
+      "NOT (name LIKE $name)",
+    );
+  });
+
+  it("parses the remaining select forms", () => {
+    for (const sql of [
+      "SELECT id FROM (SELECT id FROM users) AS u",
+      "SELECT id FROM users LEFT JOIN posts ON posts.user_id = users.id",
+      "SELECT id FROM users RIGHT JOIN tags ON tags.id = users.id",
+      "SELECT id FROM users WHERE NOT (name LIKE $name)",
+      "SELECT id FROM users WHERE id <> $id",
+      "SELECT id FROM users WHERE age <= $age",
+      "SELECT id FROM users WHERE age >= $age",
+      "SELECT id FROM users WHERE age < $age",
+      "SELECT id FROM users WHERE age > $age",
+      "SELECT id FROM users WHERE true",
+      "SELECT id FROM users WHERE false",
+      "SELECT id FROM users WHERE null",
+      "SELECT id FROM users WHERE 'o''brien' = 'x'",
+      'SELECT id FROM "a""b"',
+      "SELECT id FROM users WHERE id IN (SELECT id FROM posts)",
+      "SELECT id FROM users WHERE id NOT IN (SELECT id FROM posts)",
+      "SELECT id FROM users WHERE (SELECT id FROM posts) = id",
+      "SELECT MIN(n), MAX(amount) FROM orders",
+      "SELECT COUNT FROM users",
+      "SELECT id FROM users WHERE id = $id OR age = $age",
+      "SELECT id FROM users OFFSET 3",
+      "SELECT id FROM users GROUP BY a, b",
+      "SELECT * FROM users",
+    ])
+      roundTrip(sql);
+    expect(DefaultStatementTextRenderer.instance.render(StatementParser.parse("SELECT id FROM users WHERE (id = $id)"))).toBe(
+      "SELECT id FROM users WHERE id = $id",
+    );
+    expect(() => StatementParser.parse("INSERT INTO users")).toThrow("empty statement");
+    expect(() => StatementParser.parse("ALTER TABLE users")).toThrow("empty statement");
+    expect(() => StatementParser.parse("SELECT id FROM users extra")).toThrow("empty statement");
+    expect(() => StatementParser.parse("SELECT id FROM users WHERE 'ab")).toThrow("empty statement");
+    expect(() => StatementParser.parse('SELECT id FROM "user')).toThrow("empty statement");
+    expect(() => StatementParser.parse("SELECT id FROM users WHERE id NOT = 1")).toThrow("empty statement");
+    expect(() => StatementParser.parse("SELECT id FROM users LIMIT")).toThrow("empty statement");
+    expect(() => StatementParser.parse("SELECT id FROM users WHERE id IS")).toThrow("empty statement");
+    expect(() => StatementParser.parse("SELECT id FROM users WHERE (id = $id")).toThrow("empty statement");
+    expect(() => StatementParser.parse("SELECT id FROM 1")).toThrow("empty statement");
+  });
+
+  it("rewrites and collects the new operators", () => {
+    const same = (name: string): string => name;
+    const keep = <T>(_name: string, cell: T): T => cell;
+    const nested = new SelectStatement({
+      table: "posts",
+      fields: ["id"],
+      where: new Where(new Operator.Equals("id", 1)),
+      having: new Where(new Operator.Equals("n", 2)),
+      joins: [Join.inner("tags", "posts.id", "tags.post_id")],
+    });
+    const plain = new SelectStatement({ table: "dual", fields: ["1"] });
+    const mapped = new Where(
+      new Operator.And(
+        new Operator.Or(new Operator.IsNull(new Identifier("id")), new Operator.IsNotNull(new Identifier("id"))),
+        new Operator.Not(new Operator.Like(new Literal("a"), new Identifier("name"))),
+      ),
+    ).map(same, keep);
+    expect(DefaultStatementTextRenderer.instance.render(mapped)).toBe("(id IS NULL OR id IS NOT NULL) AND (NOT ('a' LIKE name))");
+    for (const op of [
+      new Operator.NotEquals("id", 1),
+      new Operator.GreaterThan("id", 1),
+      new Operator.LessThan("id", 1),
+      new Operator.GreaterThanOrEqual("id", 1),
+      new Operator.LessThanOrEqual("id", 1),
+      new Operator.Like("name", "a"),
+      new Operator.NotLike("name", "a"),
+      new Operator.Between("age", 1, 2),
+      new Operator.NotBetween("age", 1, 2),
+      new Operator.In("id", [1]),
+      new Operator.NotIn("id", [1]),
+      new Operator.Exists(new Subquery(nested)),
+      new Operator.Exists(new Subquery(plain)),
+    ])
+      expect(DefaultStatementTextRenderer.instance.render(new Where(op).map(same, keep)).length).toBeGreaterThan(0);
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Equals('"user"', 1)))).toBe('"user" = $user');
+    expect(new Where(new Operator.Equals('"a.b"', 1)).parameters).toEqual([
+      { name: "a.b", value: 1 },
+    ]);
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.In(new Identifier("id"), new Subquery(nested))))).toBe(
+      "id IN (SELECT id FROM posts INNER JOIN tags ON posts.id = tags.post_id WHERE id = $id HAVING n = $n)",
+    );
+    expect(
+      new Where(new Operator.NotIn(new Identifier("id"), new Subquery(nested))).parameters,
+    ).toEqual([
+      { name: "id", value: 1 },
+      { name: "n", value: 2 },
+    ]);
+    expect(
+      DefaultStatementTextRenderer.instance.render(new Where(new Operator.Between(new Literal(1), new Literal(0), new Literal(2)))),
+    ).toBe("1 BETWEEN 0 AND 2");
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.NotBetween(new Literal(1), new Literal(0), new Literal(2))))).toBe(
+      "1 NOT BETWEEN 0 AND 2",
+    );
+    expect(new Where(new Operator.NotBetween(new Literal(1), new Literal(0), new Literal(2))).parameters).toEqual(
+      [],
+    );
+    expect(
+      DefaultStatementTextRenderer.instance.render(new Where(
+        new Operator.Between(new Identifier("age"), new Identifier("low"), new Identifier("high")),
+      ).map(same, keep)),
+    ).toBe("age BETWEEN low AND high");
+    expect(
+      DefaultStatementTextRenderer.instance.render(new Where(new Operator.In(new Identifier("id"), new Subquery(plain))).map(same, keep)),
+    ).toBe("id IN (SELECT 1 FROM dual)");
+    const whereOnly = new SelectStatement({ where: new Where(new Operator.Equals("id", 1)) });
+    expect(new Where(new Operator.Exists(new Subquery(whereOnly))).map(same, keep)).toBeInstanceOf(Where);
+    const bare = new SelectStatement({ table: "posts", fields: ["id"], joins: [Join.cross("tags")] });
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Exists(new Subquery(bare))).map(same, keep))).toBe(
+      "EXISTS (SELECT id FROM posts CROSS JOIN tags)",
+    );
+    expect(new Where(new Operator.Exists(new Subquery(bare))).parameters).toEqual([]);
+    expect(new Where(new Operator.Exists(new Subquery(nested))).parameters).toEqual([
+      { name: "id", value: 1 },
+      { name: "n", value: 2 },
+    ]);
+    expect(new Where(new Operator.NotIn("id", [1, 2])).parameters).toEqual([
+      { name: "id_0", value: 1 },
+      { name: "id_1", value: 2 },
+    ]);
+    expect(new Where(new Operator.Between("age", 1, 2)).parameters).toEqual([
+      { name: "age_0", value: 1 },
+      { name: "age_1", value: 2 },
+    ]);
+    expect(new Where(new Operator.NotBetween("age", 1, 2)).parameters).toEqual([
+      { name: "age_0", value: 1 },
+      { name: "age_1", value: 2 },
+    ]);
+    expect(
+      DefaultStatementTextRenderer.instance.render(new Where(
+        new Operator.In(new Identifier("id"), new ArrayExpression([new Identifier("x")])),
+      ).map(same, keep)),
+    ).toBe("id IN ($id_0)");
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new Where(new Operator.Equals("id", 1))).map(same, keep))).toBe(
+      "id = $id",
+    );
+    expect(DefaultStatementTextRenderer.instance.render(new Where(new ArrayExpression([new Literal(1)])).map(same, keep))).toBe("1");
+    expect(Join.full("profiles", "users.id", "profiles.user_id").kind).toBe("full");
+    expect(() =>
+      DefaultStatementTextRenderer.instance.render(new SelectStatement({ table: "users", fields: ["id"], joins: [{ kind: "inner", table: "t" }] })),
+    ).toThrow("empty join");
+    expect(() =>
+      DefaultStatementTextRenderer.instance.render(
+        new SelectStatement({ table: "users", fields: ["id"], offset: -1 }),
+      ),
+    ).toThrow("negative offset");
+    expect(() => new Where(new Ghost() as IExpression).map(same, keep)).toThrow("empty expression");
+  });
+
+  it("evaluates null patterns and rejects a subquery", () => {
+    const row = { name: "ada", age: 30, id: null };
+    const evaluator = new ExpressionEvaluator();
+    expect(evaluator.evaluate(new Operator.Like("name", null), row)).toBe(false);
+    expect(evaluator.evaluate(new Operator.NotLike("name", null), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.IsNotNull(new Identifier("name")), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.Like("name", "a_a"), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.Like("name", "a%"), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.Like("name", "z%"), row)).toBe(false);
+    expect(evaluator.evaluate(new Operator.Like("name", "___"), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.Like("name", "ada%"), row)).toBe(true);
+    expect(evaluator.evaluate(new Operator.Between("age", null, 40), row)).toBe(false);
+    expect(() => evaluator.evaluate(new Operator.Like("age", 1), row)).toThrow("empty like");
+    expect(() => evaluator.evaluate(new Operator.NotIn(new Identifier("id"), new Literal(1)), row)).toThrow(
+      "empty in",
+    );
+    const query = new Subquery(new SelectStatement({ table: "dual", fields: ["1"] }));
+    expect(() => evaluator.evaluate(new Operator.Exists(query), row)).toThrow("subquery is not evaluable");
+    expect(() => evaluator.evaluate(query, row)).toThrow("subquery is not evaluable");
+  });
+});
+
+class Ghost {}