velocious 1.0.108 → 1.0.110

package/dist/src/database/drivers/mssql/column.js

@@ -0,0 +1,61 @@
+// @ts-check
+import BaseColumn from "../base-column.js";
+import ColumnsIndex from "./columns-index.js";
+import { digg } from "diggerize";
+export default class VelociousDatabaseDriversMssqlColumn extends BaseColumn {
+    /**
+     * @param {import("../base-table.js").default} table
+     * @param {Record<string, any>} data
+     */
+    constructor(table, data) {
+        super();
+        this.data = data;
+        this.table = table;
+    }
+    getAutoIncrement() { return digg(this, "data", "isIdentity") === 1; }
+    async getIndexes() {
+        const options = this.getOptions();
+        const sql = `
+      SELECT
+        sys.tables.name AS TableName,
+        sys.columns.name AS ColumnName,
+        sys.indexes.name AS index_name,
+        sys.indexes.type_desc AS IndexType,
+        sys.index_columns.is_included_column AS IsIncludedColumn,
+        sys.indexes.is_unique,
+        sys.indexes.is_primary_key,
+        sys.indexes.is_unique_constraint
+      FROM sys.indexes
+      INNER JOIN sys.index_columns ON sys.indexes.object_id = sys.index_columns.object_id AND sys.indexes.index_id = sys.index_columns.index_id
+      INNER JOIN sys.columns ON sys.index_columns.object_id = sys.columns.object_id AND sys.index_columns.column_id = sys.columns.column_id
+      INNER JOIN sys.tables ON sys.indexes.object_id = sys.tables.object_id
+      WHERE
+        sys.tables.name = ${options.quote(this.getTable().getName())} AND
+        sys.columns.name = ${options.quote(this.getName())}
+      ORDER BY
+        sys.indexes.name,
+        sys.index_columns.key_ordinal
+    `;
+        const rows = await this.getDriver().query(sql);
+        const indexes = [];
+        for (const row of rows) {
+            const index = new ColumnsIndex(this.getTable(), row);
+            indexes.push(index);
+        }
+        return indexes;
+    }
+    getDefault() { return digg(this, "data", "COLUMN_DEFAULT"); }
+    getMaxLength() { return digg(this, "data", "CHARACTER_MAXIMUM_LENGTH"); }
+    getName() { return digg(this, "data", "COLUMN_NAME"); }
+    getNull() {
+        const nullValue = digg(this, "data", "IS_NULLABLE");
+        if (nullValue == "NO") {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    getPrimaryKey() { return digg(this, "data", "isIdentity") === 1; }
+    getType() { return digg(this, "data", "DATA_TYPE"); }
+}

package/dist/src/database/drivers/mssql/columns-index.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseDriversMssqlColumnsIndex extends BaseColumnsIndex {
+}
+import BaseColumnsIndex from "../base-columns-index.js";
+//# sourceMappingURL=columns-index.d.ts.map

package/dist/src/database/drivers/mssql/columns-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns-index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/columns-index.js"],"names":[],"mappings":"AAIA;CACC;6BAH4B,0BAA0B"}

package/dist/src/database/drivers/mssql/columns-index.js

@@ -0,0 +1,4 @@
+// @ts-check
+import BaseColumnsIndex from "../base-columns-index.js";
+export default class VelociousDatabaseDriversMssqlColumnsIndex extends BaseColumnsIndex {
+}

package/dist/src/database/drivers/mssql/connect-connection.d.ts

@@ -0,0 +1,2 @@
+export default function connectConnection(connection: any): Promise<any>;
+//# sourceMappingURL=connect-connection.d.ts.map

package/dist/src/database/drivers/mssql/connect-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-connection.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/connect-connection.js"],"names":[],"mappings":"AACA,yEAUC"}

package/dist/src/database/drivers/mssql/connect-connection.js

@@ -0,0 +1,13 @@
+// Async function to connect a MS-SQL connection
+export default function connectConnection(connection) {
+    return new Promise((resolve, reject) => {
+        connection.connect((error) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}

package/dist/src/database/drivers/mssql/foreign-key.d.ts

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseDriversMssqlForeignKey extends BaseForeignKey {
+    getColumnName(): any;
+    getName(): any;
+    getTableName(): any;
+    getReferencedColumnName(): any;
+    getReferencedTableName(): any;
+}
+import BaseForeignKey from "../base-foreign-key.js";
+//# sourceMappingURL=foreign-key.d.ts.map

package/dist/src/database/drivers/mssql/foreign-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/foreign-key.js"],"names":[],"mappings":"AAKA;IACE,qBAA6D;IAC7D,eAA0D;IAC1D,oBAAyD;IACzD,+BAA2E;IAC3E,8BAAyE;CAC1E;2BAT0B,wBAAwB"}

package/dist/src/database/drivers/mssql/foreign-key.js

@@ -0,0 +1,10 @@
+// @ts-check
+import BaseForeignKey from "../base-foreign-key.js";
+import { digg } from "diggerize";
+export default class VelociousDatabaseDriversMssqlForeignKey extends BaseForeignKey {
+    getColumnName() { return digg(this, "data", "ParentColumn"); }
+    getName() { return digg(this, "data", "CONSTRAINT_NAME"); }
+    getTableName() { return digg(this, "data", "TableName"); }
+    getReferencedColumnName() { return digg(this, "data", "ReferencedColumn"); }
+    getReferencedTableName() { return digg(this, "data", "ReferencedTable"); }
+}

package/dist/src/database/drivers/mssql/index.d.ts

@@ -0,0 +1,33 @@
+export default class VelociousDatabaseDriversMssql extends Base {
+    connection: any;
+    close(): Promise<void>;
+    /**
+     * @returns {Promise<string>}
+     */
+    currentDatabase(): Promise<string>;
+    /**
+     * @returns {string}
+     */
+    primaryKeyType(): string;
+    /**
+     * @param {*} value
+     * @returns {string}
+     */
+    escape(value: any): string;
+    /**
+     * @param {*} value
+     * @returns {string}
+     */
+    quote(value: any): string;
+    /**
+     * @param {*} string
+     * @returns {string}
+     */
+    quoteColumn(string: any): string;
+    lastInsertID(): Promise<any>;
+    _options: Options;
+    _currentTransaction: any;
+}
+import Base from "../base.js";
+import Options from "./options.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/database/drivers/mssql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/index.js"],"names":[],"mappings":"AAmBA;IAMM,gBAAqD;IAYzD,uBAGC;IAgDD;;OAEG;IACH,mBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;IA2BD;;OAEG;IACH,kBAFa,MAAM,CAEiB;IA+CpC;;;OAGG;IACH,cAHW,GAAC,GACC,MAAM,CAalB;IAED;;;OAGG;IACH,aAHW,GAAC,GACC,MAAM,CAWlB;IAED;;;OAGG;IACH,oBAHW,GAAC,GACC,MAAM,CAEkD;IAuErE,6BAOC;IAIqB,kBAA2C;IAS/D,yBAAiE;CAyDpE;iBAjWgB,YAAY;oBAST,cAAc"}

package/dist/src/database/drivers/mssql/index.js

@@ -0,0 +1,304 @@
+// @ts-check
+import AlterTable from "./sql/alter-table.js";
+import Base from "../base.js";
+import CreateDatabase from "./sql/create-database.js";
+import CreateIndex from "./sql/create-index.js";
+import CreateTable from "./sql/create-table.js";
+import Delete from "./sql/delete.js";
+import DropTable from "./sql/drop-table.js";
+import { digg } from "diggerize";
+import escapeString from "sql-escape-string";
+import Insert from "./sql/insert.js";
+import Options from "./options.js";
+import mssql from "mssql";
+import QueryParser from "./query-parser.js";
+import Table from "./table.js";
+import Update from "./sql/update.js";
+import UUID from "pure-uuid";
+export default class VelociousDatabaseDriversMssql extends Base {
+    async connect() {
+        const args = this.getArgs();
+        const sqlConfig = digg(args, "sqlConfig");
+        try {
+            this.connection = new mssql.ConnectionPool(sqlConfig);
+            await this.connection.connect();
+        }
+        catch (error) {
+            // Re-throw to fix unuseable stack trace.
+            if (error instanceof Error) {
+                throw new Error(`Couldn't connect to database: ${error.message}`);
+            }
+            else {
+                throw new Error(`Couldn't connect to database: ${error}`);
+            }
+        }
+    }
+    async close() {
+        await this.connection?.close();
+        this.connection = undefined;
+    }
+    /**
+     * @param {import("../../table-data/index.js").default} tableData
+     * @returns {Promise<string[]>}
+     */
+    async alterTableSQLs(tableData) {
+        const alterArgs = { tableData, driver: this };
+        const alterTable = new AlterTable(alterArgs);
+        return await alterTable.toSQLs();
+    }
+    /**
+     * @param {string} databaseName
+     * @param {object} [args]
+     * @param {boolean} [args.ifNotExists]
+     * @returns {string[]}
+     */
+    createDatabaseSql(databaseName, args) {
+        const createArgs = Object.assign({ databaseName, driver: this }, args);
+        const createDatabase = new CreateDatabase(createArgs);
+        return createDatabase.toSql();
+    }
+    /**
+     * @param {import("../base.js").CreateIndexSqlArgs} indexData
+     * @returns {Promise<string[]>}
+     */
+    async createIndexSQLs(indexData) {
+        const createArgs = Object.assign({ driver: this }, indexData);
+        const createIndex = new CreateIndex(createArgs);
+        return await createIndex.toSQLs();
+    }
+    /**
+     * @param {import("../../table-data/index.js").default} tableData
+     * @returns {Promise<string[]>}
+     */
+    async createTableSql(tableData) {
+        const createArgs = { tableData, driver: this, indexInCreateTable: false };
+        const createTable = new CreateTable(createArgs);
+        return await createTable.toSql();
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    async currentDatabase() {
+        const rows = await this.query("SELECT DB_NAME() AS db_name");
+        return digg(rows, 0, "db_name");
+    }
+    async disableForeignKeys() {
+        await this.query("EXEC sp_MSforeachtable \"ALTER TABLE ? NOCHECK CONSTRAINT all\"");
+    }
+    async enableForeignKeys() {
+        await this.query("EXEC sp_MSforeachtable @command1=\"print '?'\", @command2=\"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\"");
+    }
+    /**
+     * @param {string} tableName
+     * @param {import("../base.js").DropTableSqlArgsType} [args]
+     * @returns {Promise<string[]>}
+     */
+    async dropTableSQLs(tableName, args = {}) {
+        const dropArgs = Object.assign({ tableName, driver: this }, args);
+        const dropTable = new DropTable(dropArgs);
+        return await dropTable.toSQLs();
+    }
+    /**
+     * @returns {string}
+     */
+    getType() { return "mssql"; }
+    /**
+     * @returns {string}
+     */
+    primaryKeyType() { return "bigint"; }
+    /**
+     * @param {string} sql
+     * @returns {Promise<import("../base.js").QueryResultType>}
+     */
+    async _queryActual(sql) {
+        let result;
+        let request, tries = 0;
+        if (this._currentTransaction) {
+            request = new mssql.Request(this._currentTransaction);
+        }
+        else {
+            request = new mssql.Request(this.connection);
+        }
+        while (true) {
+            tries++;
+            try {
+                result = await request.query(sql);
+                break;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message == "No connection is specified for that request." && tries <= 3) {
+                    this.logger.log("Reconnecting to database");
+                    await this.connect();
+                    // Retry
+                }
+                else if (error instanceof Error) {
+                    // Re-throw error because the stack-trace is broken and can't be used for app-development.
+                    throw new Error(`Query failed '${error.message}': ${sql}`);
+                }
+                else {
+                    throw new Error(`Query failed '${error}': ${sql}`);
+                }
+            }
+        }
+        return result.recordsets[0];
+    }
+    /**
+     * @param {import("../../query/index.js").default} query
+     * @returns {string}
+     */
+    queryToSql(query) { return new QueryParser({ query }).toSql(); }
+    shouldSetAutoIncrementWhenPrimaryKey() { return true; }
+    /**
+     * @param {*} value
+     * @returns {string}
+     */
+    escape(value) {
+        value = this._convertValue(value);
+        const type = typeof value;
+        if (type != "string")
+            value = `${value}`;
+        const resultWithQuotes = escapeString(value, null);
+        const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1);
+        return result;
+    }
+    /**
+     * @param {*} value
+     * @returns {string}
+     */
+    quote(value) {
+        value = this._convertValue(value);
+        const type = typeof value;
+        if (type == "number")
+            return value;
+        if (type != "string")
+            value = `${value}`;
+        return escapeString(value, null);
+    }
+    /**
+     * @param {*} string
+     * @returns {string}
+     */
+    quoteColumn(string) { return this.options().quoteColumnName(string); }
+    /**
+     * @param {string} string
+     * @returns {string}
+     */
+    quoteTable(string) { return this.options().quoteTableName(string); }
+    /**
+     * @param {string} tableName
+     * @param {string} oldColumnName
+     * @param {string} newColumnName
+     * @returns {Promise<void>}
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        await this.query(`EXEC sp_rename ${this.quote(`${tableName}.${oldColumnName}`)}, ${this.quote(newColumnName)}, 'COLUMN'`);
+    }
+    /**
+     * @param {import("../base.js").DeleteSqlArgsType} args
+     */
+    deleteSql({ tableName, conditions }) {
+        const deleteInstruction = new Delete({ conditions, driver: this, tableName });
+        return deleteInstruction.toSql();
+    }
+    /**
+     * @abstract
+     * @param {import("../base.js").InsertSqlArgsType} args
+     * @returns {string}
+     */
+    insertSql(args) {
+        const insertArgs = Object.assign({ driver: this }, args);
+        const insert = new Insert(insertArgs);
+        return insert.toSql();
+    }
+    /**
+     * @returns {Promise<Array<import("../base-table.js").default>>}
+     */
+    async getTables() {
+        const result = await this.query(`SELECT [TABLE_NAME] FROM [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_CATALOG] = DB_NAME() AND [TABLE_SCHEMA] = 'dbo'`);
+        const tables = [];
+        for (const row of result) {
+            const table = new Table(this, row);
+            tables.push(table);
+        }
+        return tables;
+    }
+    /**
+     * @param {string} name
+     * @param {object} [args]
+     * @param {boolean} args.throwError
+     * @returns {Promise<import("../base-table.js").default | undefined>}
+     */
+    async getTableByName(name, args) {
+        const result = await this.query(`SELECT [TABLE_NAME] FROM [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_CATALOG] = DB_NAME() AND [TABLE_SCHEMA] = 'dbo' AND [TABLE_NAME] = ${this.quote(name)}`);
+        if (result[0]) {
+            return new Table(this, result[0]);
+        }
+        if (args?.throwError !== false)
+            throw new Error(`Couldn't find a table by that name: ${name}`);
+    }
+    async lastInsertID() {
+        const result = await this.query("SELECT SCOPE_IDENTITY() AS last_insert_id");
+        const lastInsertID = digg(result, 0, "last_insert_id");
+        if (lastInsertID === null)
+            throw new Error("Couldn't get the last inserted ID");
+        return lastInsertID;
+    }
+    /** @returns {Options} */
+    options() {
+        if (!this._options)
+            this._options = new Options({ driver: this });
+        return this._options;
+    }
+    async _startTransactionAction() {
+        if (!this.connection)
+            throw new Error("No connection");
+        if (this._currentTransaction)
+            throw new Error("A transaction is already running");
+        this._currentTransaction = new mssql.Transaction(this.connection);
+        await this._currentTransaction.begin();
+    }
+    async _commitTransactionAction() {
+        if (!this._currentTransaction)
+            throw new Error("A transaction isn't running");
+        await this._currentTransaction.commit();
+        this._currentTransaction = null;
+    }
+    async _rollbackTransactionAction() {
+        if (!this._currentTransaction)
+            throw new Error("A transaction isn't running");
+        await this._currentTransaction.rollback();
+        this._currentTransaction = null;
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async _startSavePointAction(savePointName) {
+        await this.query(`SAVE TRANSACTION [${savePointName}]`);
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async _releaseSavePointAction(savePointName) {
+        // Do nothing in MS-SQL.
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async _rollbackSavePointAction(savePointName) {
+        await this.query(`ROLLBACK TRANSACTION [${savePointName}]`);
+    }
+    generateSavePointName() {
+        return `sp${new UUID(4).format().replaceAll("-", "")}`.substring(0, 32);
+    }
+    /**
+     * @param {import("../base.js").UpdateSqlArgsType} args
+     * @returns {string}
+     */
+    updateSql({ conditions, data, tableName }) {
+        const update = new Update({ conditions, data, driver: this, tableName });
+        return update.toSql();
+    }
+}

package/dist/src/database/drivers/mssql/options.d.ts

@@ -0,0 +1,11 @@
+export default class VelociousDatabaseDriversMssqlOptions extends QueryParserOptions {
+    /**
+     * @param {object} args
+     * @param {import("../base.js").default} args.driver
+     */
+    constructor({ driver }: {
+        driver: import("../base.js").default;
+    });
+}
+import QueryParserOptions from "../../query-parser/options.js";
+//# sourceMappingURL=options.d.ts.map

package/dist/src/database/drivers/mssql/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/options.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,wBAFG;QAA2C,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;KACtC,EAWA;CAoDF;+BArE8B,+BAA+B"}

package/dist/src/database/drivers/mssql/options.js

@@ -0,0 +1,65 @@
+// @ts-check
+import QueryParserOptions from "../../query-parser/options.js";
+export default class VelociousDatabaseDriversMssqlOptions extends QueryParserOptions {
+    /**
+     * @param {object} args
+     * @param {import("../base.js").default} args.driver
+     */
+    constructor({ driver }) {
+        const options = {
+            driver,
+            columnQuote: "\"",
+            indexQuote: "\"",
+            stringQuote: "'",
+            tableQuote: "\""
+        };
+        super(options);
+    }
+    /**
+     * @param {any} string
+     * @returns {number | string}
+     */
+    quote(string) {
+        if (!this.driver)
+            throw new Error("Driver not set");
+        return this.driver.quote(string);
+    }
+    /**
+     * @param {string} string
+     * @returns {string}
+     */
+    quoteColumnName(string) {
+        if (string.includes("[") || string.includes("]"))
+            throw new Error(`Possible SQL injection in column name: ${string}`);
+        return `[${string}]`;
+    }
+    /**
+     * @param {string} databaseName
+     * @returns {string}
+     */
+    quoteDatabaseName(databaseName) {
+        if (typeof databaseName != "string")
+            throw new Error(`Invalid database name given: ${databaseName}`);
+        if (databaseName.includes("[") || databaseName.includes("]"))
+            throw new Error(`Possible SQL injection in database name: ${databaseName}`);
+        return `[${databaseName}]`;
+    }
+    /**
+     * @param {string} string
+     * @returns {string}
+     */
+    quoteIndexName(string) {
+        if (string.includes("[") || string.includes("]"))
+            throw new Error(`Possible SQL injection in index name: ${string}`);
+        return `[${string}]`;
+    }
+    /**
+     * @param {string} string
+     * @returns {string}
+     */
+    quoteTableName(string) {
+        if (string.includes("[") || string.includes("]"))
+            throw new Error(`Possible SQL injection in table name: ${string}`);
+        return `[${string}]`;
+    }
+}

package/dist/src/database/drivers/mssql/query-parser.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseConnectionDriversMssqlQueryParser extends BaseQueryParser {
+}
+import BaseQueryParser from "../../query-parser/base-query-parser.js";
+//# sourceMappingURL=query-parser.d.ts.map

package/dist/src/database/drivers/mssql/query-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-parser.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/query-parser.js"],"names":[],"mappings":"AAIA;CACC;4BAH2B,yCAAyC"}

package/dist/src/database/drivers/mssql/query-parser.js

@@ -0,0 +1,4 @@
+// @ts-check
+import BaseQueryParser from "../../query-parser/base-query-parser.js";
+export default class VelociousDatabaseConnectionDriversMssqlQueryParser extends BaseQueryParser {
+}

package/dist/src/database/drivers/mssql/sql/alter-table.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlAlterTable extends AlterTableBase {
+}
+import AlterTableBase from "../../../query/alter-table-base.js";
+//# sourceMappingURL=alter-table.d.ts.map

package/dist/src/database/drivers/mssql/sql/alter-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-table.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/alter-table.js"],"names":[],"mappings":"AAEA;CACC;2BAH0B,oCAAoC"}

package/dist/src/database/drivers/mssql/sql/alter-table.js

@@ -0,0 +1,3 @@
+import AlterTableBase from "../../../query/alter-table-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlAlterTable extends AlterTableBase {
+}

package/dist/src/database/drivers/mssql/sql/create-database.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateDatabase extends CreateDatabaseBase {
+}
+import CreateDatabaseBase from "../../../query/create-database-base.js";
+//# sourceMappingURL=create-database.d.ts.map

package/dist/src/database/drivers/mssql/sql/create-database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-database.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/create-database.js"],"names":[],"mappings":"AAIA;CA8BC;+BAhC8B,wCAAwC"}

package/dist/src/database/drivers/mssql/sql/create-database.js

@@ -0,0 +1,27 @@
+// @ts-check
+import CreateDatabaseBase from "../../../query/create-database-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateDatabase extends CreateDatabaseBase {
+    /**
+     * @param {object} args
+     * @param {import("../../base.js").default} args.driver
+     * @param {string} args.databaseName
+     * @param {boolean} [args.ifNotExists]
+     */
+    constructor({ driver, databaseName, ifNotExists }) {
+        super({ databaseName, driver });
+        this.ifNotExists = ifNotExists;
+    }
+    toSql() {
+        const { databaseName } = this;
+        const options = this.getOptions();
+        let sql = "";
+        if (this.ifNotExists) {
+            sql += `IF NOT EXISTS(SELECT * FROM [sys].[databases] WHERE [name] = ${options.quote(databaseName)}) BEGIN `;
+        }
+        sql += `CREATE DATABASE ${options.quoteDatabaseName(databaseName)}`;
+        if (this.ifNotExists) {
+            sql += " END";
+        }
+        return [sql];
+    }
+}

package/dist/src/database/drivers/mssql/sql/create-index.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateIndex extends CreateIndexBase {
+}
+import CreateIndexBase from "../../../query/create-index-base.js";
+//# sourceMappingURL=create-index.d.ts.map

package/dist/src/database/drivers/mssql/sql/create-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-index.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/create-index.js"],"names":[],"mappings":"AAEA;CACC;4BAH2B,qCAAqC"}

package/dist/src/database/drivers/mssql/sql/create-index.js

@@ -0,0 +1,3 @@
+import CreateIndexBase from "../../../query/create-index-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateIndex extends CreateIndexBase {
+}

package/dist/src/database/drivers/mssql/sql/create-table.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateTable extends CreateTableBase {
+}
+import CreateTableBase from "../../../query/create-table-base.js";
+//# sourceMappingURL=create-table.d.ts.map

package/dist/src/database/drivers/mssql/sql/create-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-table.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/create-table.js"],"names":[],"mappings":"AAEA;CACC;4BAH2B,qCAAqC"}

package/dist/src/database/drivers/mssql/sql/create-table.js

@@ -0,0 +1,3 @@
+import CreateTableBase from "../../../query/create-table-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateTable extends CreateTableBase {
+}

package/dist/src/database/drivers/mssql/sql/delete.d.ts

@@ -0,0 +1,5 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlDelete extends DeleteBase {
+    toSql(): string;
+}
+import DeleteBase from "../../../query/delete-base.js";
+//# sourceMappingURL=delete.d.ts.map

package/dist/src/database/drivers/mssql/sql/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/delete.js"],"names":[],"mappings":"AAEA;IACE,gBAcC;CACF;uBAlBsB,+BAA+B"}