@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/statements/ExpressionEvaluator.ts

@@ -1,166 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

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

package/src/statements/IBulkInsertStatement.ts

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

package/src/statements/IBulkUpdateStatement.ts

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

package/src/statements/ICondition.ts

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

package/src/statements/IConditionVisitor.ts

@@ -1,7 +0,0 @@
-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

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

package/src/statements/ICreateTableStatement.ts

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

package/src/statements/IDeleteStatement.ts

@@ -1,6 +0,0 @@
-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

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

package/src/statements/IExpression.ts

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

package/src/statements/IInsertStatement.ts

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

package/src/statements/IReturnStatement.ts

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

package/src/statements/ISelectStatement.ts

@@ -1,6 +0,0 @@
-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

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

package/src/statements/IStatementVisitor.ts

@@ -1,27 +0,0 @@
-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

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

package/src/statements/IUpdateStatement.ts

@@ -1,6 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

package/src/statements/InsertStatement.ts

@@ -1,15 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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

package/src/statements/NotNull.ts

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