@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/statements/Aggregate.ts

@@ -1,9 +0,0 @@
-const fragment = (op: string, column: string, alias?: string): string =>
-  alias === undefined ? `${op}(${column})` : `${op}(${column}) AS ${alias}`;
-
-export const Aggregate = {
-  count: (column: string, alias?: string): string => fragment("COUNT", column, alias),
-  sum: (column: string, alias?: string): string => fragment("SUM", column, alias),
-  min: (column: string, alias?: string): string => fragment("MIN", column, alias),
-  max: (column: string, alias?: string): string => fragment("MAX", column, alias),
-};

package/src/statements/ArrayExpression.ts

@@ -1,5 +0,0 @@
-import type { IExpression } from "./IExpression.ts";
-
-export class ArrayExpression implements IExpression {
-  constructor(readonly elements: IExpression[]) {}
-}

package/src/statements/BulkDeleteStatement.ts

@@ -1,18 +0,0 @@
-import type { Parameter } from "../Parameter.ts";
-import type { IBulkDeleteStatement } from "./IBulkDeleteStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import { flattenBulkParameters } from "./BulkInsertStatement.ts";
-
-export class BulkDeleteStatement implements IBulkDeleteStatement {
-  constructor(
-    readonly table: string,
-    readonly ids: readonly string[],
-    readonly rows: readonly Parameter[][],
-  ) {}
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-
-  get parameters(): Parameter[] {
-    return flattenBulkParameters(this.ids, this.rows);
-  }
-}

package/src/statements/BulkDeleteStatementTextRenderer.ts

@@ -1,16 +0,0 @@
-import type { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
-
-export class BulkDeleteStatementTextRenderer {
-  render = (statement: BulkDeleteStatement): string => {
-    if (statement.ids.length === 0) return `DELETE FROM ${statement.table} WHERE 1 = 1`;
-    if (statement.ids.length === 1) {
-      const column = statement.ids[0]!;
-      const names = statement.rows.map((_, index) => `$${column}__${index}`).join(", ");
-      return `DELETE FROM ${statement.table} WHERE ${column} IN (${names})`;
-    }
-    const tuples = statement.rows
-      .map((_, index) => `(${statement.ids.map((column) => `$${column}__${index}`).join(", ")})`)
-      .join(", ");
-    return `DELETE FROM ${statement.table} WHERE (${statement.ids.join(", ")}) IN (${tuples})`;
-  };
-}

package/src/statements/BulkInsertStatement.ts

@@ -1,37 +0,0 @@
-import type { Cell } from "../converters/Cell.ts";
-import type { Parameter } from "../Parameter.ts";
-import type { IBulkInsertStatement } from "./IBulkInsertStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-
-const lookup = (fields: readonly Parameter[]): Map<string, Cell> => {
-  const map = new Map<string, Cell>();
-  for (const field of fields) map.set(field.name, (field.value ?? null) as Cell);
-  return map;
-};
-
-export const flattenBulkParameters = (
-  columns: readonly string[],
-  rows: readonly Parameter[][],
-): Parameter[] => {
-  const parameters: Parameter[] = [];
-  rows.forEach((row, index) => {
-    const byName = lookup(row);
-    for (const column of columns)
-      parameters.push({ name: `${column}__${index}`, value: (byName.get(column) ?? null) as Parameter["value"] });
-  });
-  return parameters;
-};
-
-export class BulkInsertStatement implements IBulkInsertStatement {
-  constructor(
-    readonly table: string,
-    readonly columns: readonly string[],
-    readonly rows: readonly Parameter[][],
-  ) {}
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-
-  get parameters(): Parameter[] {
-    return flattenBulkParameters(this.columns, this.rows);
-  }
-}

package/src/statements/BulkInsertStatementTextRenderer.ts

@@ -1,10 +0,0 @@
-import type { BulkInsertStatement } from "./BulkInsertStatement.ts";
-
-export class BulkInsertStatementTextRenderer {
-  render = (statement: BulkInsertStatement): string => {
-    const values = statement.rows.map(
-      (_, index) => `(${statement.columns.map((column) => `$${column}__${index}`).join(", ")})`,
-    );
-    return `INSERT INTO ${statement.table} (${statement.columns.join(", ")}) VALUES ${values.join(", ")}`;
-  };
-}

package/src/statements/BulkUpdateStatement.ts

@@ -1,24 +0,0 @@
-import type { Parameter } from "../Parameter.ts";
-import type { IBulkUpdateStatement } from "./IBulkUpdateStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import { flattenBulkParameters } from "./BulkInsertStatement.ts";
-
-export type BulkUpdatedRow = { fields: Parameter[]; ids: Parameter[] };
-
-export class BulkUpdateStatement implements IBulkUpdateStatement {
-  constructor(
-    readonly table: string,
-    readonly set: readonly string[],
-    readonly ids: readonly string[],
-    readonly rows: readonly BulkUpdatedRow[],
-  ) {}
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-
-  get parameters(): Parameter[] {
-    return flattenBulkParameters(
-      [...this.set, ...this.ids],
-      this.rows.map((row) => [...row.fields, ...row.ids]),
-    );
-  }
-}

package/src/statements/BulkUpdateStatementTextRenderer.ts

@@ -1,29 +0,0 @@
-import type { Cell } from "../converters/Cell.ts";
-import type { Parameter } from "../Parameter.ts";
-import type { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
-
-export class BulkUpdateStatementTextRenderer {
-  render = (statement: BulkUpdateStatement): string => {
-    const assigns = statement.set.map((column) => `${column} = data.${column}`).join(", ");
-    return `UPDATE ${statement.table} SET ${assigns} FROM ${this.source(statement)} WHERE ${this.on(statement)}`;
-  };
-
-  protected on = (statement: BulkUpdateStatement): string =>
-    statement.ids.map((column) => `${statement.table}.${column} = data.${column}`).join(" AND ");
-
-  protected source = (statement: BulkUpdateStatement): string => {
-    const columns = [...statement.set, ...statement.ids];
-    const selects = statement.rows.map((row, index) => {
-      const byName = new Map<string, Cell>();
-      for (const field of [...row.fields, ...row.ids] as Parameter[])
-        byName.set(field.name, (field.value ?? null) as Cell);
-      return `SELECT ${columns
-        .map((column) => this.cell(column, index, byName.get(column) ?? null))
-        .join(", ")}`;
-    });
-    return `(${selects.join(" UNION ALL ")}) AS data`;
-  };
-
-  protected cell = (column: string, index: number, _value: Cell): string =>
-    `$${column}__${index} AS ${column}`;
-}

package/src/statements/CheckConstraint.ts

@@ -1,9 +0,0 @@
-import type { ITableConstraint } from "./ITableConstraint.ts";
-
-export class CheckConstraint implements ITableConstraint {
-  readonly kind = "check" as const;
-  constructor(
-    readonly name: string,
-    readonly expression: string,
-  ) {}
-}

package/src/statements/Cmp.ts

@@ -1,12 +0,0 @@
-import type { Cell } from "../converters/Cell.ts";
-import type { Condition } from "./Condition.ts";
-import { Operator } from "./Operator.ts";
-
-export type Comparison = (column: string, value: Cell) => Condition;
-
-export const eq: Comparison = (column, value) => new Operator.Equals(column, value);
-export const ne: Comparison = (column, value) => new Operator.NotEquals(column, value);
-export const gt: Comparison = (column, value) => new Operator.GreaterThan(column, value);
-export const lt: Comparison = (column, value) => new Operator.LessThan(column, value);
-export const ge: Comparison = (column, value) => new Operator.GreaterThanOrEqual(column, value);
-export const le: Comparison = (column, value) => new Operator.LessThanOrEqual(column, value);

package/src/statements/Column.ts

@@ -1,10 +0,0 @@
-import type { ColumnDefault } from "./ColumnDefault.ts";
-import type { NotNull } from "./NotNull.ts";
-
-export interface Column {
-  name: string;
-  type: string;
-  default?: ColumnDefault;
-  notNull?: NotNull;
-  identity?: boolean;
-}

package/src/statements/ColumnDefault.ts

@@ -1,6 +0,0 @@
-export class ColumnDefault {
-  constructor(
-    readonly value: string,
-    readonly name?: string,
-  ) {}
-}

package/src/statements/Condition.ts

@@ -1,3 +0,0 @@
-import type { IExpression } from "./IExpression.ts";
-
-export abstract class Condition implements IExpression {}

package/src/statements/ConditionRenderer.ts

@@ -1,17 +0,0 @@
-import type { ICondition } from "./ICondition.ts";
-import type { IConditionVisitor } from "./IConditionVisitor.ts";
-import type { ExpressionRenderer } from "./ExpressionRenderer.ts";
-import { Where } from "./Where.ts";
-import { WhereText } from "./WhereText.ts";
-
-export class ConditionRenderer implements IConditionVisitor {
-  constructor(private readonly expressions: ExpressionRenderer) {}
-
-  render = (condition: ICondition): string => condition.accept(this);
-
-  visit(where: Where): string;
-  visit(where: WhereText): string;
-  visit(where: Where | WhereText): string {
-    return where instanceof Where ? this.expressions.render(where.condition) : where.rawText;
-  }
-}

package/src/statements/CreateIndexStatement.ts

@@ -1,18 +0,0 @@
-import type { ICreateIndexStatement } from "./ICreateIndexStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-
-export class CreateIndexStatement implements ICreateIndexStatement {
-  readonly name: string;
-  readonly table: string;
-  readonly columns: string[];
-  readonly unique: boolean;
-
-  constructor(name: string, table: string, columns: string[], unique = false) {
-    this.name = name;
-    this.table = table;
-    this.columns = columns;
-    this.unique = unique;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-}

package/src/statements/CreateIndexStatementTextRenderer.ts

@@ -1,11 +0,0 @@
-import type { CreateIndexStatement } from "./CreateIndexStatement.ts";
-
-export class CreateIndexStatementTextRenderer {
-  render(statement: CreateIndexStatement): string {
-    return `CREATE ${statement.unique ? "UNIQUE " : ""}INDEX ${this.quote(statement.name)} ON ${this.quote(statement.table)} (${statement.columns.map((column) => this.quote(column)).join(", ")})`;
-  }
-
-  protected quote(name: string): string {
-    return name;
-  }
-}

package/src/statements/CreateTableStatement.ts

@@ -1,18 +0,0 @@
-import type { Column } from "./Column.ts";
-import type { ICreateTableStatement } from "./ICreateTableStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import type { ITableConstraint } from "./ITableConstraint.ts";
-
-export class CreateTableStatement implements ICreateTableStatement {
-  readonly table: string;
-  readonly columns: Column[];
-  readonly constraints: ITableConstraint[];
-
-  constructor(table: string, columns: Column[], constraints: ITableConstraint[] = []) {
-    this.table = table;
-    this.columns = columns;
-    this.constraints = constraints;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-}

package/src/statements/CreateTableStatementTextRenderer.ts

@@ -1,92 +0,0 @@
-import type { CheckConstraint } from "./CheckConstraint.ts";
-import type { Column } from "./Column.ts";
-import type { CreateTableStatement } from "./CreateTableStatement.ts";
-import type { ForeignKey, ReferentialAction } from "./ForeignKey.ts";
-import type { ITableConstraint } from "./ITableConstraint.ts";
-import type { NotNull } from "./NotNull.ts";
-import type { PrimaryKey } from "./PrimaryKey.ts";
-import type { UniqueConstraint } from "./UniqueConstraint.ts";
-
-const actionKeyword: Record<ReferentialAction, string> = {
-  cascade: "CASCADE",
-  setNull: "SET NULL",
-  setDefault: "SET DEFAULT",
-  restrict: "RESTRICT",
-  noAction: "NO ACTION",
-};
-
-export class CreateTableStatementTextRenderer {
-  render(statement: CreateTableStatement): string {
-    return `CREATE TABLE ${this.quote(statement.table!)} (${this.parts(statement).join(", ")})${this.suffix()}`;
-  }
-
-  protected quote(name: string): string {
-    return name;
-  }
-
-  protected suffix(): string {
-    return "";
-  }
-
-  protected typeName(column: Column): string {
-    return column.type;
-  }
-
-  protected columnDefault(column: Column): string {
-    return column.default == null
-      ? ""
-      : column.default.name == null
-        ? ` DEFAULT ${column.default.value}`
-        : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${column.default.value}`;
-  }
-
-  protected identity(_column: Column): string {
-    return "";
-  }
-
-  protected column(column: Column): string {
-    return `${this.quote(column.name)} ${this.typeName(column)}${this.identity(column)}${this.columnDefault(column)}${this.notNullSql(column.notNull)}`;
-  }
-
-  protected constraint(constraint: ITableConstraint): string {
-    return (
-      {
-        primaryKey: (item: PrimaryKey) =>
-          `CONSTRAINT ${this.quote(item.name)} PRIMARY KEY (${this.quoted(item.columns)})`,
-        foreignKey: (item: ForeignKey) => this.foreignKey(item),
-        unique: (item: UniqueConstraint) =>
-          `CONSTRAINT ${this.quote(item.name)} UNIQUE (${this.quoted(item.columns)})`,
-        check: (item: CheckConstraint) =>
-          `CONSTRAINT ${this.quote(item.name)} CHECK (${item.expression})`,
-      } as Record<ITableConstraint["kind"], (item: ITableConstraint) => string>
-    )[constraint.kind]?.(constraint) ??
-      (() => {
-        throw new Error("empty constraint");
-      })();
-  }
-
-  private parts(statement: CreateTableStatement): string[] {
-    return statement.constraints.length === 0
-      ? statement.columns.map((column) => this.column(column))
-      : [
-          ...statement.columns.map((column) => this.column(column)),
-          ...statement.constraints.map((constraint) => this.constraint(constraint)),
-        ];
-  }
-
-  private notNullSql(value?: NotNull): string {
-    return value == null ? "" : value.name == null ? " NOT NULL" : ` CONSTRAINT ${this.quote(value.name)} NOT NULL`;
-  }
-
-  private foreignKey(fk: ForeignKey): string {
-    return `CONSTRAINT ${this.quote(fk.name)} FOREIGN KEY (${this.quoted(fk.columns)}) REFERENCES ${this.quote(fk.referencesTable)} (${this.quoted(fk.referencesColumns)})${this.actionSql("DELETE", fk.onDelete)}${this.actionSql("UPDATE", fk.onUpdate)}`;
-  }
-
-  private quoted(names: string[]): string {
-    return names.map((name) => this.quote(name)).join(", ");
-  }
-
-  private actionSql(kind: string, action?: ReferentialAction): string {
-    return action == null ? "" : ` ON ${kind} ${actionKeyword[action]}`;
-  }
-}

package/src/statements/DefaultStatementTextRenderer.ts

@@ -1,9 +0,0 @@
-import { StatementTextRenderer } from "./StatementTextRenderer.ts";
-
-export class DefaultStatementTextRenderer extends StatementTextRenderer {
-  static readonly instance = new DefaultStatementTextRenderer();
-
-  constructor() {
-    super();
-  }
-}

package/src/statements/DeleteStatement.ts

@@ -1,15 +0,0 @@
-import type { IDeleteStatement } from "./IDeleteStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import type { IWhere } from "./IWhere.ts";
-
-export class DeleteStatement implements IDeleteStatement {
-  readonly table: string;
-  readonly where?: IWhere;
-
-  constructor(table: string, where?: IWhere) {
-    this.table = table;
-    this.where = where;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-}

package/src/statements/DeleteStatementTextRenderer.ts

@@ -1,12 +0,0 @@
-import type { DeleteStatement } from "./DeleteStatement.ts";
-import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
-
-export class DeleteStatementTextRenderer {
-  constructor(private readonly text: StatementTextRenderer) {}
-
-  render(statement: DeleteStatement): string {
-    return statement.where
-      ? `DELETE FROM ${statement.table} WHERE ${this.text.render(statement.where)}`
-      : `DELETE FROM ${statement.table}`;
-  }
-}

package/src/statements/ExecuteStoredProcedureStatement.ts

@@ -1,15 +0,0 @@
-import type { Parameter } from "../Parameter.ts";
-import type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-
-export class ExecuteStoredProcedureStatement implements IExecuteStoredProcedureStatement {
-  readonly name: string;
-  readonly parameters: Parameter[];
-
-  constructor(name: string, parameters: Parameter[]) {
-    this.name = name;
-    this.parameters = parameters;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-}

package/src/statements/ExecuteStoredProcedureStatementTextRenderer.ts

@@ -1,15 +0,0 @@
-import { ParameterDirection } from "../ParameterDirection.ts";
-import type { Parameter } from "../Parameter.ts";
-import type { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
-
-const args = (parameters: Parameter[]): string =>
-  parameters
-    .filter((parameter) => parameter.direction !== ParameterDirection.ReturnValue)
-    .map((parameter) => `$${parameter.name}`)
-    .join(", ");
-
-export class ExecuteStoredProcedureStatementTextRenderer {
-  render(statement: ExecuteStoredProcedureStatement): string {
-    return `CALL ${statement.name}(${args(statement.parameters)})`;
-  }
-}

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");
-                                    })();
-}