@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/statements/SelectStatement.js

@@ -0,0 +1,25 @@
+export class SelectStatement {
+    where;
+    distinct;
+    table;
+    fields;
+    joins;
+    groupBy;
+    having;
+    orderBy;
+    limit;
+    offset;
+    constructor(options) {
+        this.where = options.where;
+        this.distinct = options.distinct ?? false;
+        this.table = options.table;
+        this.fields = options.fields ?? [];
+        this.joins = options.joins ?? [];
+        this.groupBy = options.groupBy ?? [];
+        this.having = options.having;
+        this.orderBy = options.orderBy ?? [];
+        this.limit = options.limit;
+        this.offset = options.offset;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/SelectStatementOptions.d.ts

@@ -0,0 +1,15 @@
+import type { Join } from "./Join.js";
+import type { IWhere } from "./IWhere.js";
+import type { OrderBy } from "./OrderBy.js";
+export type SelectStatementOptions = {
+    table?: string;
+    fields?: string[];
+    distinct?: boolean;
+    where?: IWhere;
+    joins?: Join[];
+    groupBy?: string[];
+    having?: IWhere;
+    orderBy?: OrderBy[];
+    limit?: number;
+    offset?: number;
+};

package/dist/statements/SelectStatementOptions.js

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

package/dist/statements/SelectStatementTextRenderer.d.ts

@@ -0,0 +1,19 @@
+import type { IWhere } from "./IWhere.js";
+import type { Join, JoinKind } from "./Join.js";
+import { type OrderBy } from "./OrderBy.js";
+import type { SelectStatement } from "./SelectStatement.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class SelectStatementTextRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render(statement: SelectStatement): string;
+    protected whereSql(where?: IWhere): string;
+    protected havingSql(having?: IWhere): string;
+    protected groupSql(columns?: string[]): string;
+    protected orderSql(order?: OrderBy[]): string;
+    protected limit(limit?: number): string;
+    protected offset(offset?: number): string;
+    protected bound(keyword: string, value?: number): string;
+    protected joinSql(joins?: Join[]): string;
+    protected keyword(kind: JoinKind): string;
+}

package/dist/statements/SelectStatementTextRenderer.js

@@ -0,0 +1,54 @@
+import { orderText } from "./OrderBy.js";
+import { Where } from "./Where.js";
+export class SelectStatementTextRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    render(statement) {
+        return `SELECT ${statement.distinct ? "DISTINCT " : ""}${statement.fields.length === 0 ? "*" : statement.fields.join(", ")} FROM ${statement.table}${this.joinSql(statement.joins)}${this.whereSql(statement.where)}${this.groupSql(statement.groupBy)}${this.havingSql(statement.having)}${this.orderSql(statement.orderBy)}${this.limit(statement.limit)}${this.offset(statement.offset)}`;
+    }
+    whereSql(where) {
+        return where ? ` WHERE ${this.text.render(where)}` : "";
+    }
+    havingSql(having) {
+        return having ? ` HAVING ${this.text.render(having)}` : "";
+    }
+    groupSql(columns) {
+        return !columns || columns.length === 0 ? "" : ` GROUP BY ${columns.join(", ")}`;
+    }
+    orderSql(order) {
+        return !order || order.length === 0 ? "" : ` ORDER BY ${order.map(orderText).join(", ")}`;
+    }
+    limit(limit) {
+        return this.bound("LIMIT", limit);
+    }
+    offset(offset) {
+        return this.bound("OFFSET", offset);
+    }
+    bound(keyword, value) {
+        if (value === undefined)
+            return "";
+        if (value < 0)
+            throw new Error(`negative ${keyword.toLowerCase()}`);
+        return ` ${keyword} ${value}`;
+    }
+    joinSql(joins) {
+        if (!joins || joins.length === 0)
+            return "";
+        return joins
+            .map((join) => join.kind === "cross"
+            ? ` CROSS JOIN ${join.table}`
+            : ` ${this.keyword(join.kind)} ${join.table} ON ${this.text.render(new Where(join.on ?? (() => { throw new Error("empty join"); })()))}`)
+            .join("");
+    }
+    keyword(kind) {
+        return {
+            inner: "INNER JOIN",
+            left: "LEFT JOIN",
+            right: "RIGHT JOIN",
+            full: "FULL JOIN",
+            cross: "CROSS JOIN",
+        }[kind];
+    }
+}

package/dist/statements/StatementEvaluator.d.ts

@@ -0,0 +1,4 @@
+import type { IStatement } from "./IStatement.js";
+export declare class StatementEvaluator {
+    evaluate: (_statement: IStatement) => void;
+}

package/dist/statements/StatementEvaluator.js

@@ -0,0 +1,3 @@
+export class StatementEvaluator {
+    evaluate = (_statement) => { };
+}

package/dist/statements/StatementParser.d.ts

@@ -0,0 +1,4 @@
+import type { IStatement } from "./IStatement.js";
+export declare class StatementParser {
+    static parse(text: string): IStatement;
+}

package/dist/statements/StatementParser.js

@@ -0,0 +1,454 @@
+import { ArrayExpression } from "./ArrayExpression.js";
+import { DeleteStatement } from "./DeleteStatement.js";
+import { Identifier } from "./Identifier.js";
+import { InsertStatement } from "./InsertStatement.js";
+import { Join } from "./Join.js";
+import { Literal } from "./Literal.js";
+import { Operator } from "./Operator.js";
+import { OrderBy } from "./OrderBy.js";
+import { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
+import { SelectStatement } from "./SelectStatement.js";
+import { Subquery } from "./Subquery.js";
+import { UpdateStatement } from "./UpdateStatement.js";
+import { Where } from "./Where.js";
+const empty = () => {
+    throw new Error("empty statement");
+};
+class Cursor {
+    text;
+    i = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    statement() {
+        const word = ["SELECT", "INSERT", "UPDATE", "DELETE"].find((name) => this.peekWord(name)) ?? empty();
+        return {
+            SELECT: () => this.selectStatement(),
+            INSERT: () => this.parseInsert(),
+            UPDATE: () => this.parseUpdate(),
+            DELETE: () => this.parseDelete(),
+        }[word]();
+    }
+    parseInsert() {
+        this.expectWord("INSERT");
+        this.expectWord("INTO");
+        const table = this.ident();
+        this.expectChar("(");
+        const columns = [this.ident()];
+        while (this.tryChar(","))
+            columns.push(this.ident());
+        this.expectChar(")");
+        this.expectWord("VALUES");
+        this.expectChar("(");
+        const values = [this.rawExpr()];
+        while (this.tryChar(","))
+            values.push(this.rawExpr());
+        this.expectChar(")");
+        const fields = columns.map((name) => ({ name, value: null }));
+        return values.length === columns.length &&
+            values.every((value, index) => value.trim() === `$${columns[index]}`)
+            ? new InsertStatement(table, fields)
+            : empty();
+    }
+    parseUpdate() {
+        this.expectWord("UPDATE");
+        const table = this.ident();
+        this.expectWord("SET");
+        const columns = [];
+        let canonical = this.assignment(columns);
+        while (this.tryChar(","))
+            canonical = this.assignment(columns) && canonical;
+        const where = this.tryWord("WHERE") ? new Where(this.expr()) : undefined;
+        const fields = columns.map((name) => ({ name, value: null }));
+        return canonical ? new UpdateStatement(table, fields, where) : empty();
+    }
+    assignment(columns) {
+        const column = this.ident();
+        this.expectChar("=");
+        const raw = this.rawExpr();
+        columns.push(column);
+        return raw.trim() === `$${column}`;
+    }
+    parseDelete() {
+        this.expectWord("DELETE");
+        this.expectWord("FROM");
+        const table = this.ident();
+        return new DeleteStatement(table, this.tryWord("WHERE") ? new Where(this.expr()) : undefined);
+    }
+    rawExpr() {
+        this.skip();
+        const start = this.i;
+        this.expr();
+        return this.text.slice(start, this.i);
+    }
+    end() {
+        this.skip();
+        if (this.i !== this.text.length)
+            empty();
+    }
+    selectStatement() {
+        this.expectWord("SELECT");
+        const distinct = this.tryWord("DISTINCT");
+        const fields = this.selectList();
+        this.expectWord("FROM");
+        const table = this.fromItem();
+        const joins = this.joins();
+        const where = this.tryWord("WHERE") ? new Where(this.expr()) : undefined;
+        const groupBy = this.tryWord("GROUP") ? this.group() : undefined;
+        const having = this.tryWord("HAVING") ? new Where(this.expr()) : undefined;
+        const orderBy = this.tryWord("ORDER") ? this.order() : undefined;
+        const limit = this.tryWord("LIMIT") ? this.integer() : undefined;
+        const offset = this.tryWord("OFFSET") ? this.integer() : undefined;
+        return new SelectStatement({
+            distinct,
+            table,
+            fields,
+            where,
+            joins,
+            groupBy,
+            having,
+            orderBy,
+            limit,
+            offset,
+        });
+    }
+    selectList() {
+        if (this.tryChar("*"))
+            return [];
+        const fields = [this.selectItem()];
+        while (this.tryChar(","))
+            fields.push(this.selectItem());
+        return fields;
+    }
+    selectItem() {
+        for (const name of ["COUNT", "SUM", "MIN", "MAX"]) {
+            const mark = this.i;
+            if (!this.tryWord(name) || !this.tryChar("(")) {
+                this.i = mark;
+                continue;
+            }
+            const arg = this.tryChar("*") ? "*" : this.ident();
+            this.expectChar(")");
+            const alias = this.tryWord("AS") ? ` AS ${this.ident()}` : "";
+            return `${name}(${arg})${alias}`;
+        }
+        const column = this.ident();
+        return this.tryWord("AS") ? `${column} AS ${this.ident()}` : column;
+    }
+    fromItem() {
+        if (!this.peek("("))
+            return this.ident();
+        const nested = this.nested();
+        this.expectWord("AS");
+        return `(${DefaultStatementTextRenderer.instance.render(nested)}) AS ${this.ident()}`;
+    }
+    nested() {
+        this.expectChar("(");
+        const query = this.selectStatement();
+        this.expectChar(")");
+        return query;
+    }
+    joins() {
+        const joins = [];
+        for (let kind = this.kind(); kind; kind = this.kind()) {
+            this.expectWord(kind === "cross"
+                ? "CROSS"
+                : kind === "inner"
+                    ? "INNER"
+                    : kind === "left"
+                        ? "LEFT"
+                        : kind === "right"
+                            ? "RIGHT"
+                            : "FULL");
+            this.expectWord("JOIN");
+            const table = this.fromItem();
+            joins.push(kind === "cross" ? Join.cross(table) : { kind, table, on: this.on() });
+        }
+        return joins;
+    }
+    kind() {
+        return this.peekWord("CROSS")
+            ? "cross"
+            : this.peekWord("INNER")
+                ? "inner"
+                : this.peekWord("LEFT")
+                    ? "left"
+                    : this.peekWord("RIGHT")
+                        ? "right"
+                        : this.peekWord("FULL")
+                            ? "full"
+                            : undefined;
+    }
+    on() {
+        this.expectWord("ON");
+        return this.expr();
+    }
+    group() {
+        this.expectWord("BY");
+        return this.list(() => this.ident());
+    }
+    order() {
+        this.expectWord("BY");
+        return this.list(() => this.orderItem());
+    }
+    orderItem() {
+        const column = this.ident();
+        if (this.tryWord("DESC"))
+            return OrderBy.desc(column);
+        this.expectWord("ASC");
+        return OrderBy.asc(column);
+    }
+    list(item) {
+        const items = [item()];
+        while (this.tryChar(","))
+            items.push(item());
+        return items;
+    }
+    expr() {
+        let left = this.and();
+        while (this.tryWord("OR"))
+            left = new Operator.Or(left, this.and());
+        return left;
+    }
+    and() {
+        let left = this.not();
+        while (this.tryWord("AND"))
+            left = new Operator.And(left, this.not());
+        return left;
+    }
+    not() {
+        if (!this.peekWord("NOT") || !this.peekAfter("NOT", "("))
+            return this.predicate();
+        this.expectWord("NOT");
+        this.expectChar("(");
+        const inner = this.expr();
+        this.expectChar(")");
+        return new Operator.Not(inner);
+    }
+    predicate() {
+        if (this.tryWord("EXISTS"))
+            return new Operator.Exists(new Subquery(this.nested()));
+        const left = this.primary();
+        if (this.tryWord("IS"))
+            return this.nullTest(left);
+        if (this.tryWord("NOT"))
+            return this.negated(left);
+        if (this.tryWord("IN"))
+            return new Operator.In(left, this.inList());
+        if (this.tryWord("BETWEEN"))
+            return this.bounds(left, false);
+        if (this.tryWord("LIKE"))
+            return new Operator.Like(left, this.param());
+        if (this.tryText("<>"))
+            return new Operator.NotEquals(left, this.primary());
+        if (this.tryText("<="))
+            return new Operator.LessThanOrEqual(left, this.primary());
+        if (this.tryText(">="))
+            return new Operator.GreaterThanOrEqual(left, this.primary());
+        if (this.tryChar("="))
+            return new Operator.Equals(left, this.primary());
+        if (this.tryChar("<"))
+            return new Operator.LessThan(left, this.primary());
+        if (this.tryChar(">"))
+            return new Operator.GreaterThan(left, this.primary());
+        return left;
+    }
+    nullTest(left) {
+        if (this.tryWord("NOT")) {
+            this.expectWord("NULL");
+            return new Operator.IsNotNull(left);
+        }
+        this.expectWord("NULL");
+        return new Operator.IsNull(left);
+    }
+    negated(left) {
+        if (this.tryWord("IN"))
+            return new Operator.NotIn(left, this.inList());
+        if (this.tryWord("BETWEEN"))
+            return this.bounds(left, true);
+        this.expectWord("LIKE");
+        return new Operator.NotLike(left, this.param());
+    }
+    bounds(left, not) {
+        const low = this.param();
+        this.expectWord("AND");
+        const high = this.param();
+        return not ? new Operator.NotBetween(left, low, high) : new Operator.Between(left, low, high);
+    }
+    inList() {
+        this.expectChar("(");
+        if (this.peekWord("SELECT")) {
+            const query = this.selectStatement();
+            this.expectChar(")");
+            return new Subquery(query);
+        }
+        const items = [this.param()];
+        while (this.tryChar(","))
+            items.push(this.param());
+        this.expectChar(")");
+        return new ArrayExpression(items);
+    }
+    primary() {
+        if (this.tryChar("(")) {
+            if (this.peekWord("SELECT")) {
+                const query = this.selectStatement();
+                this.expectChar(")");
+                return new Subquery(query);
+            }
+            const inner = this.expr();
+            this.expectChar(")");
+            return inner;
+        }
+        if (this.tryChar("$")) {
+            this.ident();
+            return new Literal(null);
+        }
+        if (this.peekDigit())
+            return new Literal(this.integer());
+        if (this.tryWord("true"))
+            return new Literal(true);
+        if (this.tryWord("false"))
+            return new Literal(false);
+        if (this.tryWord("null"))
+            return new Literal(null);
+        if (this.peek("'"))
+            return this.string();
+        return new Identifier(this.ident());
+    }
+    param() {
+        this.expectChar("$");
+        this.ident();
+        return new Literal(null);
+    }
+    string() {
+        this.expectChar("'");
+        let value = "";
+        while (this.i < this.text.length) {
+            if (this.text[this.i] === "'") {
+                if (this.text[this.i + 1] === "'") {
+                    value += "'";
+                    this.i += 2;
+                    continue;
+                }
+                this.i++;
+                return new Literal(value);
+            }
+            value += this.text[this.i++];
+        }
+        return empty();
+    }
+    ident() {
+        let name = this.part();
+        while (this.tryChar("."))
+            name += `.${this.part()}`;
+        return name;
+    }
+    part() {
+        this.skip();
+        return this.peek('"') ? this.quoted() : this.name();
+    }
+    quoted() {
+        this.expectChar('"');
+        let name = '"';
+        while (this.i < this.text.length) {
+            if (this.text[this.i] === '"') {
+                if (this.text[this.i + 1] === '"') {
+                    name += '""';
+                    this.i += 2;
+                    continue;
+                }
+                this.i++;
+                return `${name}"`;
+            }
+            name += this.text[this.i++];
+        }
+        return empty();
+    }
+    name() {
+        this.skip();
+        if (this.i >= this.text.length || !/[A-Za-z]/.test(this.at(this.i)))
+            empty();
+        const start = this.i++;
+        while (this.i < this.text.length && /[A-Za-z0-9_]/.test(this.at(this.i)))
+            this.i++;
+        return this.text.slice(start, this.i);
+    }
+    integer() {
+        this.skip();
+        const start = this.i;
+        while (this.i < this.text.length && /[0-9]/.test(this.at(this.i)))
+            this.i++;
+        if (start === this.i)
+            empty();
+        return Number(this.text.slice(start, this.i));
+    }
+    peekDigit() {
+        this.skip();
+        return /[0-9]/.test(this.at(this.i));
+    }
+    peek(token) {
+        this.skip();
+        return this.text[this.i] === token;
+    }
+    peekWord(word) {
+        const mark = this.i;
+        const matched = this.tryWord(word);
+        this.i = mark;
+        return matched;
+    }
+    peekAfter(word, token) {
+        const mark = this.i;
+        const matched = this.tryWord(word) && this.peek(token);
+        this.i = mark;
+        return matched;
+    }
+    tryWord(word) {
+        this.skip();
+        if (this.i + word.length > this.text.length)
+            return false;
+        if (this.text.slice(this.i, this.i + word.length).toLowerCase() !== word.toLowerCase())
+            return false;
+        const after = this.i + word.length;
+        if (/[A-Za-z0-9_]/.test(this.at(after)))
+            return false;
+        this.i = after;
+        return true;
+    }
+    tryChar(token) {
+        this.skip();
+        if (this.text[this.i] !== token)
+            return false;
+        this.i++;
+        return true;
+    }
+    tryText(token) {
+        this.skip();
+        if (!this.text.startsWith(token, this.i))
+            return false;
+        this.i += token.length;
+        return true;
+    }
+    expectChar(token) {
+        if (!this.tryChar(token))
+            empty();
+    }
+    expectWord(word) {
+        if (!this.tryWord(word))
+            empty();
+    }
+    skip() {
+        while (this.i < this.text.length && /\s/.test(this.at(this.i)))
+            this.i++;
+    }
+    at(index) {
+        return this.text[index] ?? "";
+    }
+}
+export class StatementParser {
+    static parse(text) {
+        const cursor = new Cursor(text);
+        const statement = cursor.statement();
+        cursor.end();
+        return statement;
+    }
+}

package/dist/statements/StatementRenderer.d.ts

@@ -0,0 +1,84 @@
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+import { BulkInsertStatement } from "./BulkInsertStatement.js";
+import { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+import { AlterTableStatement } from "./AlterTableStatement.js";
+import { CreateIndexStatement } from "./CreateIndexStatement.js";
+import { CreateTableStatement } from "./CreateTableStatement.js";
+import { CreateTriggerStatement } from "./CreateTriggerStatement.js";
+import { DeleteStatement } from "./DeleteStatement.js";
+import { DropIndexStatement } from "./DropIndexStatement.js";
+import { DropRoutineStatement } from "./DropRoutineStatement.js";
+import { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
+import { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
+import { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
+import { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
+import { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
+import { CreateBulkUpdateStoredProcedureStatement } from "./CreateBulkUpdateStoredProcedureStatement.js";
+import { CreateBulkDeleteStoredProcedureStatement } from "./CreateBulkDeleteStoredProcedureStatement.js";
+import { DropTableStatement } from "./DropTableStatement.js";
+import { DropTriggerStatement } from "./DropTriggerStatement.js";
+import { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+import { IdentityInsertStatement } from "./IdentityInsertStatement.js";
+import { InsertStatement } from "./InsertStatement.js";
+import { ReturnStatement } from "./ReturnStatement.js";
+import { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+import { SelectStatement } from "./SelectStatement.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+import { UpdateStatement } from "./UpdateStatement.js";
+export declare class StatementRenderer implements IStatementVisitor {
+    protected readonly text: StatementTextRenderer;
+    constructor(text: StatementTextRenderer);
+    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;
+    protected visitSelect(statement: SelectStatement): string;
+    protected visitInsert(statement: InsertStatement): string;
+    protected visitUpdate(statement: UpdateStatement): string;
+    protected visitDelete(statement: DeleteStatement): string;
+    protected visitCreateTable(statement: CreateTableStatement): string;
+    protected visitCreateIndex(statement: CreateIndexStatement): string;
+    protected visitExecuteStoredProcedure(statement: ExecuteStoredProcedureStatement): string;
+    protected visitReturn(statement: ReturnStatement): string;
+    protected visitSelectInsertedId(statement: SelectInsertedIdStatement): string;
+    protected visitBulkInsert(statement: BulkInsertStatement): string;
+    protected visitBulkUpdate(statement: BulkUpdateStatement): string;
+    protected visitBulkDelete(statement: BulkDeleteStatement): string;
+    protected visitDropTable(statement: DropTableStatement): string;
+    protected visitAlterTable(statement: AlterTableStatement): string;
+    protected visitDropIndex(statement: DropIndexStatement): string;
+    protected visitDropTrigger(statement: DropTriggerStatement): string;
+    protected visitCreateTrigger(statement: CreateTriggerStatement): string;
+    protected visitIdentityInsert(statement: IdentityInsertStatement): string;
+    protected visitDropRoutine(statement: DropRoutineStatement): string;
+    protected visitCreateCreateStoredProcedureStatement(statement: CreateCreateStoredProcedureStatement): string;
+    protected visitCreateReadStoredProcedureStatement(statement: CreateReadStoredProcedureStatement): string;
+    protected visitCreateUpdateStoredProcedureStatement(statement: CreateUpdateStoredProcedureStatement): string;
+    protected visitCreateDeleteStoredProcedureStatement(statement: CreateDeleteStoredProcedureStatement): string;
+    protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;
+    protected visitCreateBulkUpdateStoredProcedureStatement(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    protected visitCreateBulkDeleteStoredProcedureStatement(statement: CreateBulkDeleteStoredProcedureStatement): string;
+}