@deterministic-code/datasources 0.1.1 → 0.1.3

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

@@ -2,10 +2,24 @@ 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";
@@ -27,6 +41,20 @@ export declare class StatementRenderer implements 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;
     protected visitSelect(statement: SelectStatement): string;
     protected visitInsert(statement: InsertStatement): string;
     protected visitUpdate(statement: UpdateStatement): string;
@@ -39,4 +67,18 @@ export declare class StatementRenderer implements IStatementVisitor {
     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;
 }

package/dist/statements/StatementRenderer.js

@@ -0,0 +1,140 @@
+import { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.js";
+import { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.js";
+import { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.js";
+import { AlterTableStatementTextRenderer } from "./AlterTableStatementTextRenderer.js";
+import { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.js";
+import { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+import { CreateTriggerStatementTextRenderer } from "./CreateTriggerStatementTextRenderer.js";
+import { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.js";
+import { DropIndexStatementTextRenderer } from "./DropIndexStatementTextRenderer.js";
+import { DropRoutineStatementTextRenderer } from "./DropRoutineStatementTextRenderer.js";
+import { CreateCreateStoredProcedureStatementTextRenderer } from "./CreateCreateStoredProcedureStatementTextRenderer.js";
+import { CreateReadStoredProcedureStatementTextRenderer } from "./CreateReadStoredProcedureStatementTextRenderer.js";
+import { CreateUpdateStoredProcedureStatementTextRenderer } from "./CreateUpdateStoredProcedureStatementTextRenderer.js";
+import { CreateDeleteStoredProcedureStatementTextRenderer } from "./CreateDeleteStoredProcedureStatementTextRenderer.js";
+import { CreateBulkCreateStoredProcedureStatementTextRenderer } from "./CreateBulkCreateStoredProcedureStatementTextRenderer.js";
+import { CreateBulkUpdateStoredProcedureStatementTextRenderer } from "./CreateBulkUpdateStoredProcedureStatementTextRenderer.js";
+import { CreateBulkDeleteStoredProcedureStatementTextRenderer } from "./CreateBulkDeleteStoredProcedureStatementTextRenderer.js";
+import { DropTableStatementTextRenderer } from "./DropTableStatementTextRenderer.js";
+import { DropTriggerStatementTextRenderer } from "./DropTriggerStatementTextRenderer.js";
+import { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.js";
+import { IdentityInsertStatementTextRenderer } from "./IdentityInsertStatementTextRenderer.js";
+import { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.js";
+import { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.js";
+import { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.js";
+import { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.js";
+import { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";
+export class StatementRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    visit(statement) {
+        return ({
+            SelectStatement: () => this.visitSelect(statement),
+            InsertStatement: () => this.visitInsert(statement),
+            UpdateStatement: () => this.visitUpdate(statement),
+            DeleteStatement: () => this.visitDelete(statement),
+            CreateTableStatement: () => this.visitCreateTable(statement),
+            CreateIndexStatement: () => this.visitCreateIndex(statement),
+            ExecuteStoredProcedureStatement: () => this.visitExecuteStoredProcedure(statement),
+            ReturnStatement: () => this.visitReturn(statement),
+            BulkInsertStatement: () => this.visitBulkInsert(statement),
+            BulkUpdateStatement: () => this.visitBulkUpdate(statement),
+            BulkDeleteStatement: () => this.visitBulkDelete(statement),
+            DropTableStatement: () => this.visitDropTable(statement),
+            AlterTableStatement: () => this.visitAlterTable(statement),
+            DropIndexStatement: () => this.visitDropIndex(statement),
+            DropTriggerStatement: () => this.visitDropTrigger(statement),
+            CreateTriggerStatement: () => this.visitCreateTrigger(statement),
+            IdentityInsertStatement: () => this.visitIdentityInsert(statement),
+            DropRoutineStatement: () => this.visitDropRoutine(statement),
+            CreateCreateStoredProcedureStatement: () => this.visitCreateCreateStoredProcedureStatement(statement),
+            CreateReadStoredProcedureStatement: () => this.visitCreateReadStoredProcedureStatement(statement),
+            CreateUpdateStoredProcedureStatement: () => this.visitCreateUpdateStoredProcedureStatement(statement),
+            CreateDeleteStoredProcedureStatement: () => this.visitCreateDeleteStoredProcedureStatement(statement),
+            CreateBulkCreateStoredProcedureStatement: () => this.visitCreateBulkCreateStoredProcedureStatement(statement),
+            CreateBulkUpdateStoredProcedureStatement: () => this.visitCreateBulkUpdateStoredProcedureStatement(statement),
+            CreateBulkDeleteStoredProcedureStatement: () => this.visitCreateBulkDeleteStoredProcedureStatement(statement),
+            SelectInsertedIdStatement: () => this.visitSelectInsertedId(statement),
+        }[statement.constructor.name] ?? (() => this.visitSelectInsertedId(statement)))();
+    }
+    visitSelect(statement) {
+        return new SelectStatementTextRenderer(this.text).render(statement);
+    }
+    visitInsert(statement) {
+        return new InsertStatementTextRenderer().render(statement);
+    }
+    visitUpdate(statement) {
+        return new UpdateStatementTextRenderer(this.text).render(statement);
+    }
+    visitDelete(statement) {
+        return new DeleteStatementTextRenderer(this.text).render(statement);
+    }
+    visitCreateTable(statement) {
+        return new CreateTableStatementTextRenderer().render(statement);
+    }
+    visitCreateIndex(statement) {
+        return new CreateIndexStatementTextRenderer().render(statement);
+    }
+    visitExecuteStoredProcedure(statement) {
+        return new ExecuteStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitReturn(statement) {
+        return new ReturnStatementTextRenderer().render(statement);
+    }
+    visitSelectInsertedId(statement) {
+        return new SelectInsertedIdStatementTextRenderer().render(statement);
+    }
+    visitBulkInsert(statement) {
+        return new BulkInsertStatementTextRenderer().render(statement);
+    }
+    visitBulkUpdate(statement) {
+        return new BulkUpdateStatementTextRenderer().render(statement);
+    }
+    visitBulkDelete(statement) {
+        return new BulkDeleteStatementTextRenderer().render(statement);
+    }
+    visitDropTable(statement) {
+        return new DropTableStatementTextRenderer().render(statement);
+    }
+    visitAlterTable(statement) {
+        return new AlterTableStatementTextRenderer().renderAlter(statement);
+    }
+    visitDropIndex(statement) {
+        return new DropIndexStatementTextRenderer().render(statement);
+    }
+    visitDropTrigger(statement) {
+        return new DropTriggerStatementTextRenderer().render(statement);
+    }
+    visitCreateTrigger(statement) {
+        return new CreateTriggerStatementTextRenderer().render(statement);
+    }
+    visitIdentityInsert(statement) {
+        return new IdentityInsertStatementTextRenderer().render(statement);
+    }
+    visitDropRoutine(statement) {
+        return new DropRoutineStatementTextRenderer().render(statement);
+    }
+    visitCreateCreateStoredProcedureStatement(statement) {
+        return new CreateCreateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateReadStoredProcedureStatement(statement) {
+        return new CreateReadStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateUpdateStoredProcedureStatement(statement) {
+        return new CreateUpdateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateDeleteStoredProcedureStatement(statement) {
+        return new CreateDeleteStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateBulkCreateStoredProcedureStatement(statement) {
+        return new CreateBulkCreateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateBulkUpdateStoredProcedureStatement(statement) {
+        return new CreateBulkUpdateStoredProcedureStatementTextRenderer().render(statement);
+    }
+    visitCreateBulkDeleteStoredProcedureStatement(statement) {
+        return new CreateBulkDeleteStoredProcedureStatementTextRenderer().render(statement);
+    }
+}

package/dist/statements/StatementTextRenderer.js

@@ -0,0 +1,27 @@
+import { ConditionRenderer } from "./ConditionRenderer.js";
+import { ExpressionRenderer } from "./ExpressionRenderer.js";
+import { StatementRenderer } from "./StatementRenderer.js";
+import { Where } from "./Where.js";
+import { WhereText } from "./WhereText.js";
+export class StatementTextRenderer {
+    statements;
+    conditions;
+    constructor(statements, conditions, expressions) {
+        const expressionRenderer = expressions?.(this) ?? new ExpressionRenderer(this);
+        this.statements = statements?.(this) ?? new StatementRenderer(this);
+        this.conditions = conditions?.(expressionRenderer) ?? new ConditionRenderer(expressionRenderer);
+    }
+    render(target) {
+        if (target.constructor.name === "Where" || target.constructor.name === "WhereText") {
+            return target.accept(this.conditions);
+        }
+        if (target.constructor.name.endsWith("Statement")) {
+            return target.accept(this.statements);
+        }
+        if (target instanceof Where || target instanceof WhereText)
+            return target.accept(this.conditions);
+        return "where" in target || "fields" in target || "joins" in target || "column" in target
+            ? target.accept(this.statements)
+            : target.accept(this.conditions);
+    }
+}