@deterministic-code/datasources 0.1.0 → 0.1.2

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.d.ts

@@ -0,0 +1,8 @@
+import type { IExpression } from "./IExpression.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class ExpressionRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render: (expression: IExpression) => string;
+    private wrap;
+}

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.d.ts

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

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.d.ts

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

package/dist/statements/IBulkDeleteStatement.js

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

package/dist/statements/IBulkInsertStatement.d.ts

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

package/dist/statements/IBulkInsertStatement.js

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

package/dist/statements/IBulkUpdateStatement.d.ts

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

package/dist/statements/IBulkUpdateStatement.js

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

package/dist/statements/ICondition.d.ts

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

package/dist/statements/ICondition.js

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

package/dist/statements/IConditionVisitor.d.ts

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

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.d.ts

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

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.d.ts

@@ -0,0 +1,3 @@
+import type { IStatement } from "./IStatement.js";
+export interface ICreateTableStatement 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.d.ts

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

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/{src/statements/IExecuteStoredProcedureStatement.ts → dist/statements/IExecuteStoredProcedureStatement.d.ts}

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

package/dist/statements/IExecuteStoredProcedureStatement.js

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

package/dist/statements/IExpression.d.ts

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

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.d.ts

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

package/dist/statements/IInsertStatement.js

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

package/dist/statements/IReturnStatement.d.ts

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

package/dist/statements/IReturnStatement.js

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

package/dist/statements/ISelectStatement.d.ts

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

package/dist/statements/ISelectStatement.js

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

package/dist/statements/IStatement.d.ts

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

package/dist/statements/IStatement.js

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

package/dist/statements/IStatementVisitor.d.ts

@@ -0,0 +1,54 @@
+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";
+import type { SelectStatement } from "./SelectStatement.js";
+import type { UpdateStatement } from "./UpdateStatement.js";
+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;
+    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;
+}