@deterministic-code/datasources 0.1.1 → 0.1.3

package/dist/statements/ExpressionEvaluator.js

@@ -0,0 +1,122 @@
+import { ArrayExpression } from "./ArrayExpression.js";
+import { Identifier } from "./Identifier.js";
+import { Literal } from "./Literal.js";
+import { Operator } from "./Operator.js";
+import { Subquery } from "./Subquery.js";
+import { WhereText } from "./WhereText.js";
+import { Where } from "./Where.js";
+const isTrue = (value) => value === true;
+const like = (text, pattern) => text === null || pattern === null
+    ? false
+    : typeof text === "string" && typeof pattern === "string"
+        ? wild(text, pattern)
+        : (() => {
+            throw new Error("empty like");
+        })();
+const wild = (text, pattern) => {
+    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, low, high) => value === null || low === null || high === null ? false : compare(value, low) >= 0 && compare(value, high) <= 0;
+const equal = (left, right) => left === right;
+const compare = (left, right) => 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, parameters) => 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/dist/statements/ExpressionRenderer.js

@@ -0,0 +1,141 @@
+import { ArrayExpression } from "./ArrayExpression.js";
+import { Identifier } from "./Identifier.js";
+import { Literal } from "./Literal.js";
+import { Operator } from "./Operator.js";
+import { Subquery } from "./Subquery.js";
+import { Where } from "./Where.js";
+export class ExpressionRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    render = (expression) => {
+        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)} $${parameterName(operands.left.name)}`;
+        if (operands && operands.left instanceof Literal && operands.right instanceof Literal)
+            return `${inline(operands.left.value)} ${symbol(expression)} ${inline(operands.right.value)}`;
+        if (operands)
+            return `${this.render(operands.left)} ${symbol(expression)} ${this.render(operands.right)}`;
+        throw new Error("empty expression");
+    };
+    wrap = (child, and) => needsParens(child, and) ? `(${this.render(child)})` : this.render(child);
+}
+const symbol = (op) => 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) => value === null
+    ? "null"
+    : typeof value === "boolean"
+        ? String(value)
+        : typeof value === "string"
+            ? `'${value.replace(/'/g, "''")}'`
+            : String(value);
+const needsParens = (child, and) => 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) => 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) => parts(name)
+    .map((part) => part.length >= 2 && part.startsWith('"') && part.endsWith('"')
+    ? part.slice(1, -1).replace(/""/g, '"')
+    : part)
+    .join(".");
+const parts = (name) => {
+    const found = [];
+    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, count) => Array.from({ length: count }, (_, i) => `$${parameterName(name)}_${i}`).join(", ");

package/dist/statements/ForeignKey.js

@@ -0,0 +1,24 @@
+export const ReferentialAction = {
+    Cascade: "cascade",
+    SetNull: "setNull",
+    SetDefault: "setDefault",
+    Restrict: "restrict",
+    NoAction: "noAction",
+};
+export class ForeignKey {
+    name;
+    columns;
+    referencesTable;
+    referencesColumns;
+    onDelete;
+    onUpdate;
+    kind = "foreignKey";
+    constructor(name, columns, referencesTable, referencesColumns, onDelete, onUpdate) {
+        this.name = name;
+        this.columns = columns;
+        this.referencesTable = referencesTable;
+        this.referencesColumns = referencesColumns;
+        this.onDelete = onDelete;
+        this.onUpdate = onUpdate;
+    }
+}

package/dist/statements/IAlterTableStatement.d.ts

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

package/dist/statements/IAlterTableStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IBulkDeleteStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IBulkInsertStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IBulkUpdateStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICondition.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IConditionVisitor.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateBulkCreateStoredProcedureStatement.d.ts

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

package/dist/statements/ICreateBulkCreateStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateBulkDeleteStoredProcedureStatement.d.ts

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

package/dist/statements/ICreateBulkDeleteStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateBulkUpdateStoredProcedureStatement.d.ts

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

package/dist/statements/ICreateBulkUpdateStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateCreateStoredProcedureStatement.d.ts

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

package/dist/statements/ICreateCreateStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateDeleteStoredProcedureStatement.d.ts

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

package/dist/statements/ICreateDeleteStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateIndexStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateReadStoredProcedureStatement.d.ts

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

package/dist/statements/ICreateReadStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateRoutineStatement.d.ts

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

package/dist/statements/ICreateTableStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateTriggerStatement.d.ts

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

package/dist/statements/ICreateTriggerStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ICreateUpdateStoredProcedureStatement.d.ts

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

package/dist/statements/ICreateUpdateStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IDeleteStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IDropIndexStatement.d.ts

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

package/dist/statements/IDropIndexStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IDropRoutineStatement.d.ts

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

package/dist/statements/IDropRoutineStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IDropTableStatement.d.ts

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

package/dist/statements/IDropTableStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IDropTriggerStatement.d.ts

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

package/dist/statements/IDropTriggerStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IExecuteStoredProcedureStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IExpression.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IIdentityInsertStatement.d.ts

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

package/dist/statements/IIdentityInsertStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IInsertStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IReturnStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ISelectStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IStatementVisitor.d.ts

@@ -1,10 +1,24 @@
 import type { BulkDeleteStatement } from "./BulkDeleteStatement.js";
 import type { BulkInsertStatement } from "./BulkInsertStatement.js";
 import type { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+import type { AlterTableStatement } from "./AlterTableStatement.js";
 import type { CreateIndexStatement } from "./CreateIndexStatement.js";
 import type { CreateTableStatement } from "./CreateTableStatement.js";
+import type { CreateTriggerStatement } from "./CreateTriggerStatement.js";
 import type { DeleteStatement } from "./DeleteStatement.js";
+import type { DropIndexStatement } from "./DropIndexStatement.js";
+import type { DropRoutineStatement } from "./DropRoutineStatement.js";
+import type { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
+import type { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
+import type { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
+import type { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
+import type { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
+import type { CreateBulkUpdateStoredProcedureStatement } from "./CreateBulkUpdateStoredProcedureStatement.js";
+import type { CreateBulkDeleteStoredProcedureStatement } from "./CreateBulkDeleteStoredProcedureStatement.js";
+import type { DropTableStatement } from "./DropTableStatement.js";
+import type { DropTriggerStatement } from "./DropTriggerStatement.js";
 import type { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+import type { IdentityInsertStatement } from "./IdentityInsertStatement.js";
 import type { InsertStatement } from "./InsertStatement.js";
 import type { ReturnStatement } from "./ReturnStatement.js";
 import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
@@ -23,4 +37,18 @@ export interface IStatementVisitor {
     visit(statement: BulkInsertStatement): string;
     visit(statement: BulkUpdateStatement): string;
     visit(statement: BulkDeleteStatement): string;
+    visit(statement: DropTableStatement): string;
+    visit(statement: AlterTableStatement): string;
+    visit(statement: DropIndexStatement): string;
+    visit(statement: DropTriggerStatement): string;
+    visit(statement: CreateTriggerStatement): string;
+    visit(statement: IdentityInsertStatement): string;
+    visit(statement: DropRoutineStatement): string;
+    visit(statement: CreateCreateStoredProcedureStatement): string;
+    visit(statement: CreateReadStoredProcedureStatement): string;
+    visit(statement: CreateUpdateStoredProcedureStatement): string;
+    visit(statement: CreateDeleteStoredProcedureStatement): string;
+    visit(statement: CreateBulkCreateStoredProcedureStatement): string;
+    visit(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    visit(statement: CreateBulkDeleteStoredProcedureStatement): string;
 }

package/dist/statements/IStatementVisitor.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/ITableConstraint.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IUpdateStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/IWhere.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/Identifier.js

@@ -0,0 +1,6 @@
+export class Identifier {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}

package/dist/statements/IdentityInsertStatement.d.ts

@@ -0,0 +1,11 @@
+import type { IIdentityInsertStatement } from "./IIdentityInsertStatement.js";
+import type { InsertStatement } from "./InsertStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class IdentityInsertStatement implements IIdentityInsertStatement {
+    readonly table: string;
+    readonly idColumn: string;
+    readonly inserts: readonly InsertStatement[];
+    readonly identity: boolean;
+    constructor(table: string, idColumn: string, inserts: readonly InsertStatement[], identity?: boolean);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/IdentityInsertStatement.js

@@ -0,0 +1,13 @@
+export class IdentityInsertStatement {
+    table;
+    idColumn;
+    inserts;
+    identity;
+    constructor(table, idColumn, inserts, identity = false) {
+        this.table = table;
+        this.idColumn = idColumn;
+        this.inserts = inserts;
+        this.identity = identity;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/IdentityInsertStatementTextRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { IdentityInsertStatement } from "./IdentityInsertStatement.js";
+import type { InsertStatement } from "./InsertStatement.js";
+export declare class IdentityInsertStatementTextRenderer {
+    render(statement: IdentityInsertStatement): string;
+    protected insert(statement: InsertStatement): string;
+}

package/dist/statements/IdentityInsertStatementTextRenderer.js

@@ -0,0 +1,8 @@
+export class IdentityInsertStatementTextRenderer {
+    render(statement) {
+        return statement.inserts.map((insert) => this.insert(insert)).join("\n");
+    }
+    insert(statement) {
+        return `INSERT INTO ${statement.table} (${statement.fields.map((field) => field.name).join(", ")}) VALUES (${statement.fields.map((field) => String(field.value)).join(", ")});`;
+    }
+}

package/dist/statements/InsertStatement.js

@@ -0,0 +1,9 @@
+export class InsertStatement {
+    table;
+    fields;
+    constructor(table, fields) {
+        this.table = table;
+        this.fields = fields;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/InsertStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class InsertStatementTextRenderer {
+    render(statement) {
+        return `INSERT INTO ${statement.table} (${statement.fields.map((field) => field.name).join(", ")}) VALUES (${statement.fields.map((field) => `$${field.name}`).join(", ")})`;
+    }
+}

package/dist/statements/Join.js

@@ -0,0 +1,10 @@
+import { Identifier } from "./Identifier.js";
+import { Operator } from "./Operator.js";
+const equality = (left, right) => new Operator.Equals(new Identifier(left), new Identifier(right));
+export const Join = {
+    inner: (table, left, right) => ({ kind: "inner", table, on: equality(left, right) }),
+    left: (table, left, right) => ({ kind: "left", table, on: equality(left, right) }),
+    right: (table, left, right) => ({ kind: "right", table, on: equality(left, right) }),
+    full: (table, left, right) => ({ kind: "full", table, on: equality(left, right) }),
+    cross: (table) => ({ kind: "cross", table }),
+};

package/dist/statements/Literal.js

@@ -0,0 +1,6 @@
+export class Literal {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}

package/dist/statements/Native.js

@@ -0,0 +1,7 @@
+export class Native {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+}
+export const n = (text) => new Native(text);

package/dist/statements/NotNull.js

@@ -0,0 +1,6 @@
+export class NotNull {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}