@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/statements/ExpressionEvaluator.ts

@@ -0,0 +1,166 @@
+import type { Scalar } from "../builders/Scalar.ts";
+import { ArrayExpression } from "./ArrayExpression.ts";
+import { Identifier } from "./Identifier.ts";
+import type { IExpression } from "./IExpression.ts";
+import { Literal } from "./Literal.ts";
+import { Operator } from "./Operator.ts";
+import { Subquery } from "./Subquery.ts";
+import { WhereText } from "./WhereText.ts";
+import { Where } from "./Where.ts";
+
+const isTrue = (value: Scalar): boolean => value === true;
+
+const like = (text: Scalar, pattern: Scalar): boolean =>
+  text === null || pattern === null
+    ? false
+    : typeof text === "string" && typeof pattern === "string"
+      ? wild(text, pattern)
+      : (() => {
+          throw new Error("empty like");
+        })();
+
+const wild = (text: string, pattern: string): boolean => {
+  let t = 0;
+  let p = 0;
+  let starT = -1;
+  let starP = -1;
+  while (t < text.length) {
+    if (p < pattern.length && (pattern[p] === "_" || pattern[p] === text[t])) {
+      t++;
+      p++;
+    } else if (p < pattern.length && pattern[p] === "%") {
+      starP = p++;
+      starT = t;
+    } else if (starP >= 0) {
+      p = starP + 1;
+      t = ++starT;
+    } else return false;
+  }
+  while (p < pattern.length && pattern[p] === "%") p++;
+  return p === pattern.length;
+};
+
+const between = (value: Scalar, low: Scalar, high: Scalar): boolean =>
+  value === null || low === null || high === null ? false : compare(value, low) >= 0 && compare(value, high) <= 0;
+
+const equal = (left: Scalar, right: Scalar): boolean => left === right;
+
+const compare = (left: Scalar, right: Scalar): number =>
+  typeof left === "number" && typeof right === "number"
+    ? left - right
+    : typeof left === "bigint" && typeof right === "bigint"
+      ? Number(left - right)
+      : typeof left === "string" && typeof right === "string"
+        ? left < right
+          ? -1
+          : left > right
+            ? 1
+            : 0
+        : (() => {
+            throw new Error("empty compare");
+          })();
+
+export class ExpressionEvaluator {
+  evaluate = (expression: IExpression, parameters?: Record<string, Scalar>): Scalar =>
+    expression instanceof Where
+      ? this.evaluate(expression.condition, parameters)
+      : expression instanceof WhereText
+        ? (() => {
+            throw new Error("text where is not evaluable");
+          })()
+        : expression instanceof Identifier
+          ? (parameters?.[expression.name] ?? null)
+          : expression instanceof Literal
+            ? expression.value
+            : expression instanceof Operator.Not
+              ? !isTrue(this.evaluate(expression.argument, parameters))
+              : expression instanceof Operator.IsNull
+                ? this.evaluate(expression.argument, parameters) === null
+                : expression instanceof Operator.IsNotNull
+                  ? this.evaluate(expression.argument, parameters) !== null
+                  : expression instanceof Operator.Like
+                    ? like(this.evaluate(expression.left, parameters), this.evaluate(expression.right, parameters))
+                    : expression instanceof Operator.NotLike
+                      ? !like(this.evaluate(expression.left, parameters), this.evaluate(expression.right, parameters))
+                      : expression instanceof Operator.Between
+                        ? between(
+                            this.evaluate(expression.value, parameters),
+                            this.evaluate(expression.low, parameters),
+                            this.evaluate(expression.high, parameters),
+                          )
+                        : expression instanceof Operator.NotBetween
+                          ? !between(
+                              this.evaluate(expression.value, parameters),
+                              this.evaluate(expression.low, parameters),
+                              this.evaluate(expression.high, parameters),
+                            )
+                          : expression instanceof Operator.NotIn
+                            ? expression.right instanceof ArrayExpression
+                              ? !expression.right.elements.some((element) =>
+                                  equal(
+                                    this.evaluate(expression.left, parameters),
+                                    this.evaluate(element, parameters),
+                                  ),
+                                )
+                              : (() => {
+                                  throw new Error("empty in");
+                                })()
+                            : expression instanceof Operator.Exists || expression instanceof Subquery
+                              ? (() => {
+                                  throw new Error("subquery is not evaluable");
+                                })()
+                              : expression instanceof Operator.And
+                ? isTrue(this.evaluate(expression.left, parameters)) &&
+                  isTrue(this.evaluate(expression.right, parameters))
+                : expression instanceof Operator.Or
+                  ? isTrue(this.evaluate(expression.left, parameters)) ||
+                    isTrue(this.evaluate(expression.right, parameters))
+                  : expression instanceof Operator.In
+                    ? expression.right instanceof ArrayExpression
+                      ? expression.right.elements.some((element) =>
+                          equal(
+                            this.evaluate(expression.left, parameters),
+                            this.evaluate(element, parameters),
+                          ),
+                        )
+                      : (() => {
+                          throw new Error("empty in");
+                        })()
+                    : expression instanceof Operator.Equals
+                      ? equal(
+                          this.evaluate(expression.left, parameters),
+                          this.evaluate(expression.right, parameters),
+                        )
+                      : expression instanceof Operator.NotEquals
+                        ? !equal(
+                            this.evaluate(expression.left, parameters),
+                            this.evaluate(expression.right, parameters),
+                          )
+                        : expression instanceof Operator.GreaterThan
+                          ? compare(
+                              this.evaluate(expression.left, parameters),
+                              this.evaluate(expression.right, parameters),
+                            ) > 0
+                          : expression instanceof Operator.LessThan
+                            ? compare(
+                                this.evaluate(expression.left, parameters),
+                                this.evaluate(expression.right, parameters),
+                              ) < 0
+                            : expression instanceof Operator.GreaterThanOrEqual
+                              ? compare(
+                                  this.evaluate(expression.left, parameters),
+                                  this.evaluate(expression.right, parameters),
+                                ) >= 0
+                              : expression instanceof Operator.LessThanOrEqual
+                                ? compare(
+                                    this.evaluate(expression.left, parameters),
+                                    this.evaluate(expression.right, parameters),
+                                  ) <= 0
+                                : expression instanceof ArrayExpression
+                                  ? (() => {
+                                      throw new Error("array is not a scalar");
+                                    })()
+                                  : (() => {
+                                      throw new Error("empty expression");
+                                    })();
+}

package/src/statements/ExpressionRenderer.ts

@@ -0,0 +1,161 @@
+import type { Cell } from "../converters/Cell.ts";
+import { ArrayExpression } from "./ArrayExpression.ts";
+import type { IExpression } from "./IExpression.ts";
+import { Identifier } from "./Identifier.ts";
+import { Literal } from "./Literal.ts";
+import { Operator } from "./Operator.ts";
+import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
+import { Subquery } from "./Subquery.ts";
+import { Where } from "./Where.ts";
+
+export class ExpressionRenderer {
+  constructor(private readonly text: StatementTextRenderer) {}
+
+  render = (expression: IExpression): string => {
+    if (expression instanceof Where) return this.render(expression.condition);
+    if (expression instanceof Identifier) return expression.name;
+    if (expression instanceof Literal) return inline(expression.value);
+    if (expression instanceof ArrayExpression) return expression.elements.map((e) => this.render(e)).join(", ");
+    if (expression instanceof Operator.Not) return `NOT (${this.render(expression.argument)})`;
+    if (expression instanceof Operator.IsNull) return `${this.render(expression.argument)} IS NULL`;
+    if (expression instanceof Operator.IsNotNull) return `${this.render(expression.argument)} IS NOT NULL`;
+    if (expression instanceof Operator.Exists) return `EXISTS ${this.render(expression.argument)}`;
+    if (expression instanceof Subquery) return `(${this.text.render(expression.query)})`;
+    if (
+      expression instanceof Operator.In &&
+      expression.left instanceof Identifier &&
+      expression.right instanceof ArrayExpression
+    )
+      return expression.right.elements.length === 0
+        ? "1 = 0"
+        : `${expression.left.name} IN (${slots(expression.left.name, expression.right.elements.length)})`;
+    if (
+      expression instanceof Operator.In &&
+      expression.left instanceof Identifier &&
+      expression.right instanceof Subquery
+    )
+      return `${expression.left.name} IN ${this.render(expression.right)}`;
+    if (
+      expression instanceof Operator.NotIn &&
+      expression.left instanceof Identifier &&
+      expression.right instanceof ArrayExpression
+    )
+      return expression.right.elements.length === 0
+        ? "1 = 1"
+        : `${expression.left.name} NOT IN (${slots(expression.left.name, expression.right.elements.length)})`;
+    if (
+      expression instanceof Operator.NotIn &&
+      expression.left instanceof Identifier &&
+      expression.right instanceof Subquery
+    )
+      return `${expression.left.name} NOT IN ${this.render(expression.right)}`;
+    if (
+      (expression instanceof Operator.Between || expression instanceof Operator.NotBetween) &&
+      expression.value instanceof Identifier &&
+      expression.low instanceof Literal &&
+      expression.high instanceof Literal
+    ) {
+      const word = expression instanceof Operator.NotBetween ? "NOT BETWEEN" : "BETWEEN";
+      return `${expression.value.name} ${word} $${parameterName(expression.value.name)}_0 AND $${parameterName(expression.value.name)}_1`;
+    }
+    if (expression instanceof Operator.Between)
+      return `${this.render(expression.value)} BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
+    if (expression instanceof Operator.NotBetween)
+      return `${this.render(expression.value)} NOT BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
+    if (expression instanceof Operator.And)
+      return `${this.wrap(expression.left, true)} AND ${this.wrap(expression.right, true)}`;
+    if (expression instanceof Operator.Or)
+      return `${this.wrap(expression.left, false)} OR ${this.wrap(expression.right, false)}`;
+    const operands = expression instanceof Operator ? pair(expression) : undefined;
+    if (operands && operands.left instanceof Identifier && operands.right instanceof Literal)
+      return `${operands.left.name} ${symbol(expression as Operator)} $${parameterName(operands.left.name)}`;
+    if (operands && operands.left instanceof Literal && operands.right instanceof Literal)
+      return `${inline(operands.left.value)} ${symbol(expression as Operator)} ${inline(operands.right.value)}`;
+    if (operands)
+      return `${this.render(operands.left)} ${symbol(expression as Operator)} ${this.render(operands.right)}`;
+    throw new Error("empty expression");
+  };
+
+  private wrap = (child: IExpression, and: boolean): string =>
+    needsParens(child, and) ? `(${this.render(child)})` : this.render(child);
+}
+
+const symbol = (op: Operator): string =>
+  op instanceof Operator.Equals
+    ? "="
+    : op instanceof Operator.NotEquals
+      ? "<>"
+      : op instanceof Operator.GreaterThan
+        ? ">"
+        : op instanceof Operator.LessThan
+          ? "<"
+          : op instanceof Operator.GreaterThanOrEqual
+            ? ">="
+            : op instanceof Operator.LessThanOrEqual
+              ? "<="
+              : op instanceof Operator.Like
+                ? "LIKE"
+                : op instanceof Operator.NotLike
+                  ? "NOT LIKE"
+                  : "IN";
+
+const inline = (value: Cell): string =>
+  value === null
+    ? "null"
+    : typeof value === "boolean"
+      ? String(value)
+      : typeof value === "string"
+        ? `'${value.replace(/'/g, "''")}'`
+        : String(value);
+
+const needsParens = (child: IExpression, and: boolean): boolean =>
+  child instanceof Where
+    ? needsParens(child.condition, and)
+    : child instanceof Operator.Not ||
+      child instanceof Operator.In ||
+      child instanceof Operator.NotIn ||
+      (child instanceof Operator.And && !and) ||
+      (child instanceof Operator.Or && and);
+
+const pair = (
+  expression: Operator,
+): { left: IExpression; right: IExpression } | undefined =>
+  expression instanceof Operator.Equals ||
+  expression instanceof Operator.NotEquals ||
+  expression instanceof Operator.GreaterThan ||
+  expression instanceof Operator.LessThan ||
+  expression instanceof Operator.GreaterThanOrEqual ||
+  expression instanceof Operator.LessThanOrEqual ||
+  expression instanceof Operator.And ||
+  expression instanceof Operator.Or ||
+  expression instanceof Operator.In ||
+  expression instanceof Operator.Like ||
+  expression instanceof Operator.NotLike
+    ? expression
+    : undefined;
+
+const parameterName = (name: string): string =>
+  parts(name)
+    .map((part) =>
+      part.length >= 2 && part.startsWith('"') && part.endsWith('"')
+        ? part.slice(1, -1).replace(/""/g, '"')
+        : part,
+    )
+    .join(".");
+
+const parts = (name: string): string[] => {
+  const found: string[] = [];
+  let start = 0;
+  let quoted = false;
+  for (let i = 0; i < name.length; i++) {
+    if (name[i] === '"') quoted = !quoted;
+    if (name[i] !== "." || quoted) continue;
+    found.push(name.slice(start, i));
+    start = i + 1;
+  }
+  found.push(name.slice(start));
+  return found;
+};
+
+const slots = (name: string, count: number): string =>
+  Array.from({ length: count }, (_, i) => `$${parameterName(name)}_${i}`).join(", ");

package/src/statements/ForeignKey.ts

@@ -0,0 +1,23 @@
+import type { ITableConstraint } from "./ITableConstraint.ts";
+
+export const ReferentialAction = {
+  Cascade: "cascade",
+  SetNull: "setNull",
+  SetDefault: "setDefault",
+  Restrict: "restrict",
+  NoAction: "noAction",
+} as const;
+
+export type ReferentialAction = (typeof ReferentialAction)[keyof typeof ReferentialAction];
+
+export class ForeignKey implements ITableConstraint {
+  readonly kind = "foreignKey" as const;
+  constructor(
+    readonly name: string,
+    readonly columns: string[],
+    readonly referencesTable: string,
+    readonly referencesColumns: string[],
+    readonly onDelete?: ReferentialAction,
+    readonly onUpdate?: ReferentialAction,
+  ) {}
+}

package/src/statements/IBulkDeleteStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface IBulkDeleteStatement extends IStatement {}

package/src/statements/IBulkInsertStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface IBulkInsertStatement extends IStatement {}

package/src/statements/IBulkUpdateStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface IBulkUpdateStatement extends IStatement {}

package/src/statements/ICondition.ts

@@ -0,0 +1,5 @@
+import type { IConditionVisitor } from "./IConditionVisitor.ts";
+
+export interface ICondition {
+  accept(visitor: IConditionVisitor): string;
+}

package/src/statements/IConditionVisitor.ts

@@ -0,0 +1,7 @@
+import type { Where } from "./Where.ts";
+import type { WhereText } from "./WhereText.ts";
+
+export interface IConditionVisitor {
+  visit(where: Where): string;
+  visit(where: WhereText): string;
+}

package/src/statements/ICreateIndexStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface ICreateIndexStatement extends IStatement {}

package/src/statements/ICreateTableStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface ICreateTableStatement extends IStatement {}

package/src/statements/IDeleteStatement.ts

@@ -0,0 +1,6 @@
+import type { IStatement } from "./IStatement.ts";
+import type { IWhere } from "./IWhere.ts";
+
+export interface IDeleteStatement extends IStatement {
+  readonly where?: IWhere;
+}

package/src/statements/IExecuteStoredProcedureStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface IExecuteStoredProcedureStatement extends IStatement {}

package/src/statements/IExpression.ts

@@ -0,0 +1 @@
+export interface IExpression {}

package/src/statements/IInsertStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface IInsertStatement extends IStatement {}

package/src/statements/IReturnStatement.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.ts";
+
+export interface IReturnStatement extends IStatement {}

package/src/statements/ISelectStatement.ts

@@ -0,0 +1,6 @@
+import type { IStatement } from "./IStatement.ts";
+import type { IWhere } from "./IWhere.ts";
+
+export interface ISelectStatement extends IStatement {
+  readonly where?: IWhere;
+}

package/src/statements/IStatement.ts

@@ -0,0 +1,5 @@
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+
+export interface IStatement {
+  accept(visitor: IStatementVisitor): string;
+}

package/src/statements/IStatementVisitor.ts

@@ -0,0 +1,27 @@
+import type { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
+import type { BulkInsertStatement } from "./BulkInsertStatement.ts";
+import type { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
+import type { CreateIndexStatement } from "./CreateIndexStatement.ts";
+import type { CreateTableStatement } from "./CreateTableStatement.ts";
+import type { DeleteStatement } from "./DeleteStatement.ts";
+import type { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
+import type { InsertStatement } from "./InsertStatement.ts";
+import type { ReturnStatement } from "./ReturnStatement.ts";
+import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
+import type { SelectStatement } from "./SelectStatement.ts";
+import type { UpdateStatement } from "./UpdateStatement.ts";
+
+export interface IStatementVisitor {
+  visit(statement: SelectStatement): string;
+  visit(statement: InsertStatement): string;
+  visit(statement: UpdateStatement): string;
+  visit(statement: DeleteStatement): string;
+  visit(statement: CreateTableStatement): string;
+  visit(statement: CreateIndexStatement): string;
+  visit(statement: ExecuteStoredProcedureStatement): string;
+  visit(statement: ReturnStatement): string;
+  visit(statement: SelectInsertedIdStatement): string;
+  visit(statement: BulkInsertStatement): string;
+  visit(statement: BulkUpdateStatement): string;
+  visit(statement: BulkDeleteStatement): string;
+}

package/src/statements/ITableConstraint.ts

@@ -0,0 +1,6 @@
+export type TableConstraintKind = "primaryKey" | "foreignKey" | "unique" | "check";
+
+export interface ITableConstraint {
+  readonly kind: TableConstraintKind;
+  readonly name: string;
+}

package/src/statements/IUpdateStatement.ts

@@ -0,0 +1,6 @@
+import type { IStatement } from "./IStatement.ts";
+import type { IWhere } from "./IWhere.ts";
+
+export interface IUpdateStatement extends IStatement {
+  readonly where?: IWhere;
+}

package/src/statements/IWhere.ts

@@ -0,0 +1,7 @@
+import type { Parameter } from "../Parameter.ts";
+import type { ICondition } from "./ICondition.ts";
+import type { IExpression } from "./IExpression.ts";
+
+export interface IWhere extends IExpression, ICondition {
+  readonly parameters?: Parameter[];
+}

package/src/statements/Identifier.ts

@@ -0,0 +1,5 @@
+import type { IExpression } from "./IExpression.ts";
+
+export class Identifier implements IExpression {
+  constructor(readonly name: string) {}
+}

package/src/statements/InsertStatement.ts

@@ -0,0 +1,15 @@
+import type { Field } from "../builders/Field.ts";
+import type { IInsertStatement } from "./IInsertStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+
+export class InsertStatement implements IInsertStatement {
+  readonly table: string;
+  readonly fields: Field[];
+
+  constructor(table: string, fields: Field[]) {
+    this.table = table;
+    this.fields = fields;
+  }
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}

package/src/statements/InsertStatementTextRenderer.ts

@@ -0,0 +1,7 @@
+import type { InsertStatement } from "./InsertStatement.ts";
+
+export class InsertStatementTextRenderer {
+  render(statement: InsertStatement): string {
+    return `INSERT INTO ${statement.table} (${statement.fields.map((field) => field.name).join(", ")}) VALUES (${statement.fields.map((field) => `$${field.name}`).join(", ")})`;
+  }
+}

package/src/statements/Join.ts

@@ -0,0 +1,26 @@
+import { Identifier } from "./Identifier.ts";
+import type { IExpression } from "./IExpression.ts";
+import { Operator } from "./Operator.ts";
+
+export type JoinKind = "inner" | "left" | "right" | "full" | "cross";
+
+export type Join = {
+  kind: JoinKind;
+  table: string;
+  on?: IExpression;
+};
+
+const equality = (left: string, right: string): IExpression =>
+  new Operator.Equals(new Identifier(left), new Identifier(right));
+
+export const Join = {
+  inner: (table: string, left: string, right: string): Join =>
+    ({ kind: "inner", table, on: equality(left, right) }),
+  left: (table: string, left: string, right: string): Join =>
+    ({ kind: "left", table, on: equality(left, right) }),
+  right: (table: string, left: string, right: string): Join =>
+    ({ kind: "right", table, on: equality(left, right) }),
+  full: (table: string, left: string, right: string): Join =>
+    ({ kind: "full", table, on: equality(left, right) }),
+  cross: (table: string): Join => ({ kind: "cross", table }),
+};

package/src/statements/Literal.ts

@@ -0,0 +1,6 @@
+import type { Cell } from "../converters/Cell.ts";
+import type { IExpression } from "./IExpression.ts";
+
+export class Literal implements IExpression {
+  constructor(readonly value: Cell) {}
+}

package/src/statements/Native.ts

@@ -0,0 +1,5 @@
+export class Native {
+  constructor(readonly text: string) {}
+}
+
+export const n = (text: string): Native => new Native(text);

package/src/statements/NotNull.ts

@@ -0,0 +1,3 @@
+export class NotNull {
+  constructor(readonly name?: string) {}
+}