@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/statements/AlterTableStatementTextRenderer.js

@@ -0,0 +1,33 @@
+import { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+export class AlterTableStatementTextRenderer extends CreateTableStatementTextRenderer {
+    renderAlter(statement) {
+        return `ALTER TABLE ${this.quote(statement.table)} ${this.actionSql(statement.action)}`;
+    }
+    actionSql(action) {
+        return ({
+            addColumn: (item) => `ADD COLUMN ${this.column(item.column)}`,
+            dropColumn: (item) => `DROP COLUMN ${this.quote(item.name)}`,
+            alterColumn: (item) => this.alterColumn(item.column),
+            renameColumn: (item) => {
+                const rename = item;
+                return `RENAME COLUMN ${this.quote(rename.from)} TO ${this.quote(rename.to)}`;
+            },
+            renameTable: (item) => `RENAME TO ${this.quote(item.to)}`,
+            addConstraint: (item) => `ADD ${this.constraint(item.constraint)}`,
+            dropConstraint: (item) => `DROP CONSTRAINT ${this.quote(item.name)}`,
+        }[action.kind] ??
+            (() => {
+                throw new Error("empty alter");
+            }))(action);
+    }
+    alterColumn(column) {
+        return `ALTER COLUMN ${this.quote(column.name)} TYPE ${this.typeName(column)}${this.columnDefault(column)}${this.notNullClause(column)}`;
+    }
+    notNullClause(column) {
+        return column.notNull == null
+            ? ""
+            : column.notNull.name == null
+                ? " NOT NULL"
+                : ` CONSTRAINT ${this.quote(column.notNull.name)} NOT NULL`;
+    }
+}

package/dist/statements/ArrayExpression.d.ts

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

package/dist/statements/ArrayExpression.js

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

package/dist/statements/BulkDeleteStatement.d.ts

@@ -0,0 +1,11 @@
+import type { Parameter } from "../Parameter.js";
+import type { IBulkDeleteStatement } from "./IBulkDeleteStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class BulkDeleteStatement implements IBulkDeleteStatement {
+    readonly table: string;
+    readonly ids: readonly string[];
+    readonly rows: readonly Parameter[][];
+    constructor(table: string, ids: readonly string[], rows: readonly Parameter[][]);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/BulkDeleteStatement.js

@@ -0,0 +1,15 @@
+import { flattenBulkParameters } from "./BulkInsertStatement.js";
+export class BulkDeleteStatement {
+    table;
+    ids;
+    rows;
+    constructor(table, ids, rows) {
+        this.table = table;
+        this.ids = ids;
+        this.rows = rows;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return flattenBulkParameters(this.ids, this.rows);
+    }
+}

package/dist/statements/BulkDeleteStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+export declare class BulkDeleteStatementTextRenderer {
+    render: (statement: BulkDeleteStatement) => string;
+}

package/dist/statements/BulkDeleteStatementTextRenderer.js

@@ -0,0 +1,15 @@
+export class BulkDeleteStatementTextRenderer {
+    render = (statement) => {
+        if (statement.ids.length === 0)
+            return `DELETE FROM ${statement.table} WHERE 1 = 1`;
+        if (statement.ids.length === 1) {
+            const column = statement.ids[0];
+            const names = statement.rows.map((_, index) => `$${column}__${index}`).join(", ");
+            return `DELETE FROM ${statement.table} WHERE ${column} IN (${names})`;
+        }
+        const tuples = statement.rows
+            .map((_, index) => `(${statement.ids.map((column) => `$${column}__${index}`).join(", ")})`)
+            .join(", ");
+        return `DELETE FROM ${statement.table} WHERE (${statement.ids.join(", ")}) IN (${tuples})`;
+    };
+}

package/dist/statements/BulkInsertStatement.d.ts

@@ -0,0 +1,12 @@
+import type { Parameter } from "../Parameter.js";
+import type { IBulkInsertStatement } from "./IBulkInsertStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare const flattenBulkParameters: (columns: readonly string[], rows: readonly Parameter[][]) => Parameter[];
+export declare class BulkInsertStatement implements IBulkInsertStatement {
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly rows: readonly Parameter[][];
+    constructor(table: string, columns: readonly string[], rows: readonly Parameter[][]);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/BulkInsertStatement.js

@@ -0,0 +1,29 @@
+const lookup = (fields) => {
+    const map = new Map();
+    for (const field of fields)
+        map.set(field.name, (field.value ?? null));
+    return map;
+};
+export const flattenBulkParameters = (columns, rows) => {
+    const parameters = [];
+    rows.forEach((row, index) => {
+        const byName = lookup(row);
+        for (const column of columns)
+            parameters.push({ name: `${column}__${index}`, value: (byName.get(column) ?? null) });
+    });
+    return parameters;
+};
+export class BulkInsertStatement {
+    table;
+    columns;
+    rows;
+    constructor(table, columns, rows) {
+        this.table = table;
+        this.columns = columns;
+        this.rows = rows;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return flattenBulkParameters(this.columns, this.rows);
+    }
+}

package/dist/statements/BulkInsertStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { BulkInsertStatement } from "./BulkInsertStatement.js";
+export declare class BulkInsertStatementTextRenderer {
+    render: (statement: BulkInsertStatement) => string;
+}

package/dist/statements/BulkInsertStatementTextRenderer.js

@@ -0,0 +1,6 @@
+export class BulkInsertStatementTextRenderer {
+    render = (statement) => {
+        const values = statement.rows.map((_, index) => `(${statement.columns.map((column) => `$${column}__${index}`).join(", ")})`);
+        return `INSERT INTO ${statement.table} (${statement.columns.join(", ")}) VALUES ${values.join(", ")}`;
+    };
+}

package/dist/statements/BulkUpdateStatement.d.ts

@@ -0,0 +1,16 @@
+import type { Parameter } from "../Parameter.js";
+import type { IBulkUpdateStatement } from "./IBulkUpdateStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export type BulkUpdatedRow = {
+    fields: Parameter[];
+    ids: Parameter[];
+};
+export declare class BulkUpdateStatement implements IBulkUpdateStatement {
+    readonly table: string;
+    readonly set: readonly string[];
+    readonly ids: readonly string[];
+    readonly rows: readonly BulkUpdatedRow[];
+    constructor(table: string, set: readonly string[], ids: readonly string[], rows: readonly BulkUpdatedRow[]);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/BulkUpdateStatement.js

@@ -0,0 +1,17 @@
+import { flattenBulkParameters } from "./BulkInsertStatement.js";
+export class BulkUpdateStatement {
+    table;
+    set;
+    ids;
+    rows;
+    constructor(table, set, ids, rows) {
+        this.table = table;
+        this.set = set;
+        this.ids = ids;
+        this.rows = rows;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return flattenBulkParameters([...this.set, ...this.ids], this.rows.map((row) => [...row.fields, ...row.ids]));
+    }
+}

package/dist/statements/BulkUpdateStatementTextRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { Cell } from "../converters/Cell.js";
+import type { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+export declare class BulkUpdateStatementTextRenderer {
+    render: (statement: BulkUpdateStatement) => string;
+    protected on: (statement: BulkUpdateStatement) => string;
+    protected source: (statement: BulkUpdateStatement) => string;
+    protected cell: (column: string, index: number, _value: Cell) => string;
+}

package/dist/statements/BulkUpdateStatementTextRenderer.js

@@ -0,0 +1,20 @@
+export class BulkUpdateStatementTextRenderer {
+    render = (statement) => {
+        const assigns = statement.set.map((column) => `${column} = data.${column}`).join(", ");
+        return `UPDATE ${statement.table} SET ${assigns} FROM ${this.source(statement)} WHERE ${this.on(statement)}`;
+    };
+    on = (statement) => statement.ids.map((column) => `${statement.table}.${column} = data.${column}`).join(" AND ");
+    source = (statement) => {
+        const columns = [...statement.set, ...statement.ids];
+        const selects = statement.rows.map((row, index) => {
+            const byName = new Map();
+            for (const field of [...row.fields, ...row.ids])
+                byName.set(field.name, (field.value ?? null));
+            return `SELECT ${columns
+                .map((column) => this.cell(column, index, byName.get(column) ?? null))
+                .join(", ")}`;
+        });
+        return `(${selects.join(" UNION ALL ")}) AS data`;
+    };
+    cell = (column, index, _value) => `$${column}__${index} AS ${column}`;
+}

package/dist/statements/CheckConstraint.d.ts

@@ -0,0 +1,7 @@
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class CheckConstraint implements ITableConstraint {
+    readonly name: string;
+    readonly expression: string;
+    readonly kind: "check";
+    constructor(name: string, expression: string);
+}

package/dist/statements/CheckConstraint.js

@@ -0,0 +1,9 @@
+export class CheckConstraint {
+    name;
+    expression;
+    kind = "check";
+    constructor(name, expression) {
+        this.name = name;
+        this.expression = expression;
+    }
+}

package/dist/statements/Cmp.d.ts

@@ -0,0 +1,9 @@
+import type { Cell } from "../converters/Cell.js";
+import type { Condition } from "./Condition.js";
+export type Comparison = (column: string, value: Cell) => Condition;
+export declare const eq: Comparison;
+export declare const ne: Comparison;
+export declare const gt: Comparison;
+export declare const lt: Comparison;
+export declare const ge: Comparison;
+export declare const le: Comparison;

package/dist/statements/Cmp.js

@@ -0,0 +1,7 @@
+import { Operator } from "./Operator.js";
+export const eq = (column, value) => new Operator.Equals(column, value);
+export const ne = (column, value) => new Operator.NotEquals(column, value);
+export const gt = (column, value) => new Operator.GreaterThan(column, value);
+export const lt = (column, value) => new Operator.LessThan(column, value);
+export const ge = (column, value) => new Operator.GreaterThanOrEqual(column, value);
+export const le = (column, value) => new Operator.LessThanOrEqual(column, value);

package/dist/statements/Column.d.ts

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

package/dist/statements/Column.js

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

package/dist/statements/ColumnDefault.d.ts

@@ -0,0 +1,5 @@
+export declare class ColumnDefault {
+    readonly value: string;
+    readonly name?: string | undefined;
+    constructor(value: string, name?: string | undefined);
+}

package/dist/statements/ColumnDefault.js

@@ -0,0 +1,8 @@
+export class ColumnDefault {
+    value;
+    name;
+    constructor(value, name) {
+        this.value = value;
+        this.name = name;
+    }
+}

package/dist/statements/Condition.d.ts

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

package/dist/statements/Condition.js

@@ -0,0 +1,2 @@
+export class Condition {
+}

package/dist/statements/ConditionRenderer.d.ts

@@ -0,0 +1,12 @@
+import type { ICondition } from "./ICondition.js";
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { ExpressionRenderer } from "./ExpressionRenderer.js";
+import { Where } from "./Where.js";
+import { WhereText } from "./WhereText.js";
+export declare class ConditionRenderer implements IConditionVisitor {
+    private readonly expressions;
+    constructor(expressions: ExpressionRenderer);
+    render: (condition: ICondition) => string;
+    visit(where: Where): string;
+    visit(where: WhereText): string;
+}

package/dist/statements/ConditionRenderer.js

@@ -0,0 +1,11 @@
+import { Where } from "./Where.js";
+export class ConditionRenderer {
+    expressions;
+    constructor(expressions) {
+        this.expressions = expressions;
+    }
+    render = (condition) => condition.accept(this);
+    visit(where) {
+        return where instanceof Where ? this.expressions.render(where.condition) : where.rawText;
+    }
+}

package/dist/statements/CreateBulkCreateStoredProcedureStatement.d.ts

@@ -0,0 +1,13 @@
+import type { ICreateBulkCreateStoredProcedureStatement } from "./ICreateBulkCreateStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateBulkCreateStoredProcedureStatement implements ICreateBulkCreateStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly RoutineParameter[];
+    readonly payload: RoutineParameter;
+    readonly key: string;
+    readonly keyType: string;
+    constructor(name: string, table: string, columns: readonly RoutineParameter[], payload: RoutineParameter, key: string, keyType: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateBulkCreateStoredProcedureStatement.js

@@ -0,0 +1,17 @@
+export class CreateBulkCreateStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    payload;
+    key;
+    keyType;
+    constructor(name, table, columns, payload, key, keyType) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.payload = payload;
+        this.key = key;
+        this.keyType = keyType;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateBulkCreateStoredProcedureStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
+export declare class CreateBulkCreateStoredProcedureStatementTextRenderer {
+    render(_statement: CreateBulkCreateStoredProcedureStatement): string;
+}

package/dist/statements/CreateBulkCreateStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateBulkCreateStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/CreateBulkDeleteStoredProcedureStatement.d.ts

@@ -0,0 +1,13 @@
+import type { ICreateBulkDeleteStoredProcedureStatement } from "./ICreateBulkDeleteStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateBulkDeleteStoredProcedureStatement implements ICreateBulkDeleteStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly RoutineParameter[];
+    readonly payload: RoutineParameter;
+    readonly key: string;
+    readonly keyType: string;
+    constructor(name: string, table: string, columns: readonly RoutineParameter[], payload: RoutineParameter, key: string, keyType: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateBulkDeleteStoredProcedureStatement.js

@@ -0,0 +1,17 @@
+export class CreateBulkDeleteStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    payload;
+    key;
+    keyType;
+    constructor(name, table, columns, payload, key, keyType) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.payload = payload;
+        this.key = key;
+        this.keyType = keyType;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateBulkDeleteStoredProcedureStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { CreateBulkDeleteStoredProcedureStatement } from "./CreateBulkDeleteStoredProcedureStatement.js";
+export declare class CreateBulkDeleteStoredProcedureStatementTextRenderer {
+    render(_statement: CreateBulkDeleteStoredProcedureStatement): string;
+}

package/dist/statements/CreateBulkDeleteStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateBulkDeleteStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/CreateBulkUpdateStoredProcedureStatement.d.ts

@@ -0,0 +1,13 @@
+import type { ICreateBulkUpdateStoredProcedureStatement } from "./ICreateBulkUpdateStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateBulkUpdateStoredProcedureStatement implements ICreateBulkUpdateStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly RoutineParameter[];
+    readonly payload: RoutineParameter;
+    readonly key: string;
+    readonly keyType: string;
+    constructor(name: string, table: string, columns: readonly RoutineParameter[], payload: RoutineParameter, key: string, keyType: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateBulkUpdateStoredProcedureStatement.js

@@ -0,0 +1,17 @@
+export class CreateBulkUpdateStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    payload;
+    key;
+    keyType;
+    constructor(name, table, columns, payload, key, keyType) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.payload = payload;
+        this.key = key;
+        this.keyType = keyType;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateBulkUpdateStoredProcedureStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { CreateBulkUpdateStoredProcedureStatement } from "./CreateBulkUpdateStoredProcedureStatement.js";
+export declare class CreateBulkUpdateStoredProcedureStatementTextRenderer {
+    render(_statement: CreateBulkUpdateStoredProcedureStatement): string;
+}

package/dist/statements/CreateBulkUpdateStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateBulkUpdateStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/CreateCreateStoredProcedureStatement.d.ts

@@ -0,0 +1,16 @@
+import type { ICreateCreateStoredProcedureStatement } from "./ICreateCreateStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateCreateStoredProcedureStatement implements ICreateCreateStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly parameters: readonly RoutineParameter[];
+    readonly key: string;
+    readonly keyType: string;
+    readonly writable: readonly string[];
+    readonly generatedKey: boolean;
+    readonly auditUpdated?: string | undefined;
+    constructor(name: string, table: string, columns: readonly string[], parameters: readonly RoutineParameter[], key: string, keyType: string, writable: readonly string[], generatedKey?: boolean, auditUpdated?: string | undefined);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateCreateStoredProcedureStatement.js

@@ -0,0 +1,23 @@
+export class CreateCreateStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    parameters;
+    key;
+    keyType;
+    writable;
+    generatedKey;
+    auditUpdated;
+    constructor(name, table, columns, parameters, key, keyType, writable, generatedKey = false, auditUpdated) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.parameters = parameters;
+        this.key = key;
+        this.keyType = keyType;
+        this.writable = writable;
+        this.generatedKey = generatedKey;
+        this.auditUpdated = auditUpdated;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateCreateStoredProcedureStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
+export declare class CreateCreateStoredProcedureStatementTextRenderer {
+    render(_statement: CreateCreateStoredProcedureStatement): string;
+}

package/dist/statements/CreateCreateStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateCreateStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/CreateDeleteStoredProcedureStatement.d.ts

@@ -0,0 +1,17 @@
+import type { ICreateDeleteStoredProcedureStatement } from "./ICreateDeleteStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateDeleteStoredProcedureStatement implements ICreateDeleteStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly parameters: readonly RoutineParameter[];
+    readonly key: string;
+    readonly keyType: string;
+    readonly writable: readonly string[];
+    readonly byProperties: readonly string[];
+    readonly generatedKey: boolean;
+    readonly auditUpdated?: string | undefined;
+    constructor(name: string, table: string, columns: readonly string[], parameters: readonly RoutineParameter[], key: string, keyType: string, writable: readonly string[], byProperties?: readonly string[], generatedKey?: boolean, auditUpdated?: string | undefined);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateDeleteStoredProcedureStatement.js

@@ -0,0 +1,25 @@
+export class CreateDeleteStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    parameters;
+    key;
+    keyType;
+    writable;
+    byProperties;
+    generatedKey;
+    auditUpdated;
+    constructor(name, table, columns, parameters, key, keyType, writable, byProperties = [], generatedKey = false, auditUpdated) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.parameters = parameters;
+        this.key = key;
+        this.keyType = keyType;
+        this.writable = writable;
+        this.byProperties = byProperties;
+        this.generatedKey = generatedKey;
+        this.auditUpdated = auditUpdated;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateDeleteStoredProcedureStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
+export declare class CreateDeleteStoredProcedureStatementTextRenderer {
+    render(_statement: CreateDeleteStoredProcedureStatement): string;
+}

package/dist/statements/CreateDeleteStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateDeleteStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/CreateIndexStatement.d.ts

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

package/dist/statements/CreateIndexStatement.js

@@ -0,0 +1,13 @@
+export class CreateIndexStatement {
+    name;
+    table;
+    columns;
+    unique;
+    constructor(name, table, columns, unique = false) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.unique = unique;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateIndexStatementTextRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { CreateIndexStatement } from "./CreateIndexStatement.js";
+export declare class CreateIndexStatementTextRenderer {
+    render(statement: CreateIndexStatement): string;
+    protected quote(name: string): string;
+}

package/dist/statements/CreateIndexStatementTextRenderer.js

@@ -0,0 +1,8 @@
+export class CreateIndexStatementTextRenderer {
+    render(statement) {
+        return `CREATE ${statement.unique ? "UNIQUE " : ""}INDEX ${this.quote(statement.name)} ON ${this.quote(statement.table)} (${statement.columns.map((column) => this.quote(column)).join(", ")})`;
+    }
+    quote(name) {
+        return name;
+    }
+}