@mikro-orm/sql 7.0.0-dev.311 → 7.0.0-dev.313

package/dialects/oracledb/OracleNativeQueryBuilder.js

@@ -0,0 +1,249 @@
+import { raw, RawQueryFragment, Utils } from '@mikro-orm/core';
+import { QueryType } from '../../query/enums.js';
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
+/** @internal */
+export function markOutBindings(obj) {
+    Object.defineProperty(obj, '__outBindings', {
+        value: true,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+}
+/** @internal */
+export class OracleNativeQueryBuilder extends NativeQueryBuilder {
+    as(alias) {
+        this.wrap('(', `) ${this.platform.quoteIdentifier(alias)}`);
+        return this;
+    }
+    compile() {
+        if (!this.type) {
+            throw new Error('No query type provided');
+        }
+        this.parts.length = 0;
+        this.params.length = 0;
+        /* v8 ignore next 3: query comment branch */
+        if (this.options.comment) {
+            this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
+        }
+        let copy;
+        if (this.options.onConflict && !Utils.isEmpty(Utils.asArray(this.options.data)[0])) {
+            this.compileUpsert();
+        }
+        else {
+            if (this.options.returning && Array.isArray(this.options.data) && this.options.data.length > 1) {
+                copy = [...this.options.data];
+                this.options.data.length = 1;
+            }
+            switch (this.type) {
+                case QueryType.SELECT:
+                case QueryType.COUNT:
+                    this.compileSelect();
+                    break;
+                case QueryType.INSERT:
+                    this.compileInsert();
+                    break;
+                case QueryType.UPDATE:
+                    this.compileUpdate();
+                    break;
+                case QueryType.DELETE:
+                    this.compileDelete();
+                    break;
+                case QueryType.TRUNCATE:
+                    this.compileTruncate();
+                    break;
+            }
+            this.addOnConflictClause();
+        }
+        if (this.options.returning) {
+            const isUpsert = this.options.onConflict && !Utils.isEmpty(Utils.asArray(this.options.data)[0]);
+            const prefix = isUpsert ? `${this.getTableName()}.` : '';
+            const fields = this.options.returning.map(field => prefix + this.quote(Array.isArray(field) ? field[0] : field));
+            const into = this.options.returning.map(field => ':out_' + (Array.isArray(field) ? field[0] : field));
+            const outBindings = this.options.returning.map(field => {
+                const name = 'out_' + (Array.isArray(field) ? field[0] : field);
+                const type = Array.isArray(field) ? field[1] : 'string';
+                return [name, type];
+            });
+            markOutBindings(outBindings);
+            this.parts.push(`returning ${fields.join(', ')}`);
+            this.parts.push(`into ${into.join(', ')}`);
+            this.params.push(outBindings);
+        }
+        this.addLockClause();
+        if (!copy) {
+            return this.combineParts();
+        }
+        // multi insert with returning
+        const sql = this.parts.join(' ');
+        const blockLines = [];
+        const block2Lines = [];
+        const keys = Object.keys(copy[0]);
+        const last = this.params[this.params.length - 1];
+        /* v8 ignore next 3: defensive check — output bindings are always set by compile() */
+        if (!Array.isArray(last) || !('__outBindings' in last) || !last.__outBindings) {
+            throw new Error('Output bindings are required for multi insert with returning');
+        }
+        const outBindings = {};
+        markOutBindings(outBindings);
+        for (let i = 0; i < copy.length; i++) {
+            const params = [];
+            for (const key of keys) {
+                /* v8 ignore next 3: undefined value branch in multi-insert */
+                if (typeof copy[i][key] === 'undefined') {
+                    params.push(this.platform.usesDefaultKeyword() ? raw('default') : null);
+                }
+                else {
+                    params.push(copy[i][key]);
+                }
+            }
+            // we need to interpolate to allow proper escaping
+            const formatted = this.platform.formatQuery(sql, params).replaceAll(`'`, `''`);
+            /* v8 ignore next 3: returning field type branches */
+            const using = this.options.returning.map(field => {
+                const name = Array.isArray(field) ? field[0] : field;
+                const type = Array.isArray(field) ? field[1] : 'string';
+                outBindings[`out_${name}__${i}`] = {
+                    dir: this.platform.mapToBindType('out'),
+                    type: this.platform.mapToBindType(type),
+                };
+                return `out :out_${name}__${i}`;
+            });
+            blockLines.push(` execute immediate '${formatted}' using ${using.join(', ')};`);
+            block2Lines.push(` execute immediate '${sql}' using ${using.join(', ')};`);
+        }
+        const block = `begin\n${blockLines.join('\n')}\n end;`;
+        const block2 = `begin\n${block2Lines.join('\n')}\n end;`;
+        // save raw query without interpolation for logging,
+        Object.defineProperty(outBindings, '__rawQuery', {
+            value: block2,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+        this.options.data = copy;
+        return { sql: block, params: [outBindings] };
+    }
+    compileTruncate() {
+        super.compileTruncate();
+        this.parts.push('drop all storage cascade');
+    }
+    combineParts() {
+        let sql = this.parts.join(' ');
+        const last = this.params[this.params.length - 1];
+        if (this.options.wrap) {
+            const [a, b] = this.options.wrap;
+            sql = `${a}${sql}${b}`;
+        }
+        if (!(Array.isArray(last) && '__outBindings' in last && last.__outBindings)) {
+            return { sql, params: this.params };
+        }
+        const out = this.params.pop();
+        const outBindings = {};
+        markOutBindings(outBindings);
+        this.params.push(outBindings);
+        for (const item of out) {
+            outBindings[item[0]] = {
+                dir: this.platform.mapToBindType('out'),
+                type: this.platform.mapToBindType(item[1]),
+            };
+        }
+        return { sql, params: this.params };
+    }
+    compileUpsert() {
+        const clause = this.options.onConflict;
+        const dataAsArray = Utils.asArray(this.options.data);
+        const keys = Object.keys(dataAsArray[0]);
+        const parts = [];
+        for (const data of dataAsArray) {
+            for (const key of keys) {
+                this.params.push(data[key]);
+            }
+            parts.push(`select ${keys.map(k => `? as ${this.quote(k)}`).join(', ')} from dual`);
+        }
+        this.parts.push(`merge into ${this.getTableName()}`);
+        this.parts.push(`using (${parts.join(' union all ')}) tsource`);
+        /* v8 ignore next 4: RawQueryFragment conflict fields branch */
+        if (clause.fields instanceof RawQueryFragment) {
+            this.parts.push(clause.fields.sql);
+            this.params.push(...clause.fields.params);
+        }
+        else if (clause.fields.length > 0) {
+            const fields = clause.fields.map(field => {
+                const col = this.quote(field);
+                return `${this.getTableName()}.${col} = tsource.${col}`;
+            });
+            this.parts.push(`on (${fields.join(' and ')})`);
+        }
+        const sourceColumns = keys.map(field => `tsource.${this.quote(field)}`).join(', ');
+        const destinationColumns = keys.map(field => this.quote(field)).join(', ');
+        this.parts.push(`when not matched then insert (${destinationColumns}) values (${sourceColumns})`);
+        if (!clause.ignore) {
+            /* v8 ignore next: merge type branch */
+            if (!clause.merge || Array.isArray(clause.merge)) {
+                const mergeParts = (clause.merge || keys)
+                    .filter(field => !Array.isArray(clause.fields) || !clause.fields.includes(field))
+                    .filter((field) => keys.includes(field)) // only reference columns present in the source data
+                    .map((column) => `${this.quote(column)} = tsource.${this.quote(column)}`);
+                /* v8 ignore next 10: empty mergeParts branch */
+                if (mergeParts.length > 0) {
+                    this.parts.push('when matched');
+                    if (clause.where) {
+                        this.parts.push(`and ${clause.where.sql}`);
+                        this.params.push(...clause.where.params);
+                    }
+                    this.parts.push('then update set');
+                    this.parts.push(mergeParts.join(', '));
+                }
+            } /* v8 ignore start: object-form merge branch */
+            else if (typeof clause.merge === 'object') {
+                this.parts.push('when matched');
+                if (clause.where) {
+                    this.parts.push(`and ${clause.where.sql}`);
+                    this.params.push(...clause.where.params);
+                }
+                this.parts.push('then update set');
+                const parts = Object.entries(clause.merge).map(([key, value]) => {
+                    this.params.push(value);
+                    return `${this.getTableName()}.${this.quote(key)} = ?`;
+                });
+                this.parts.push(parts.join(', '));
+            }
+            /* v8 ignore stop */
+        }
+    }
+    compileSelect() {
+        this.parts.push('select');
+        this.addHintComment();
+        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        if (this.options.joins) {
+            for (const join of this.options.joins) {
+                this.parts.push(join.sql);
+                this.params.push(...join.params);
+            }
+        }
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.params.push(...this.options.where.params);
+        }
+        if (this.options.groupBy) {
+            const fields = this.options.groupBy.map(field => this.quote(field));
+            this.parts.push(`group by ${fields.join(', ')}`);
+        }
+        if (this.options.having) {
+            this.parts.push(`having ${this.options.having.sql}`);
+            this.params.push(...this.options.having.params);
+        }
+        if (this.options.orderBy) {
+            this.parts.push(`order by ${this.options.orderBy}`);
+        }
+        if (this.options.offset != null) {
+            this.parts.push(`offset ? rows`);
+            this.params.push(this.options.offset);
+        }
+        if (this.options.limit != null) {
+            this.parts.push(`fetch next ? rows only`);
+            this.params.push(this.options.limit);
+        }
+    }
+}

package/dialects/oracledb/index.d.ts

@@ -0,0 +1,2 @@
+export * from './OracleDialect.js';
+export * from './OracleNativeQueryBuilder.js';

package/dialects/oracledb/index.js

@@ -0,0 +1,2 @@
+export * from './OracleDialect.js';
+export * from './OracleNativeQueryBuilder.js';

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -19,7 +19,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return `set names '${charset}';\n\n`;
     }
     getCreateDatabaseSQL(name) {
-        return `create database ${name}`;
+        return `create database ${this.quote(name)}`;
     }
     getListTablesSQL() {
         return (`select table_name, table_schema as schema_name, ` +
@@ -617,8 +617,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
     appendComments(table) {
         const sql = [];
         if (table.comment) {
-            const comment = this.platform.quoteValue(table.comment).replace(/^'|'$/g, '');
-            sql.push(`comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(this.processComment(comment))}`);
+            const comment = this.platform.quoteValue(this.processComment(table.comment));
+            sql.push(`comment on table ${table.getQuotedName()} is ${comment}`);
         }
         for (const column of table.getColumns()) {
             if (column.comment) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.311",
+  "version": "7.0.0-dev.313",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^6.6.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.311"
+    "@mikro-orm/core": "7.0.0-dev.313"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/NativeQueryBuilder.d.ts

@@ -38,14 +38,14 @@ interface Options {
     onConflict?: OnConflictClause;
     lockMode?: LockMode;
     lockTables?: string[];
-    returning?: (string | RawQueryFragment)[];
+    returning?: (string | RawQueryFragment | [name: string, type: unknown])[];
     comment?: string[];
     hintComment?: string[];
     flags?: Set<QueryFlag>;
     wrap?: [prefix: string, suffix: string];
     ctes?: CteClause[];
 }
-interface TableOptions {
+export interface TableOptions {
     schema?: string;
     indexHint?: string;
     alias?: string;
@@ -108,7 +108,7 @@ export declare class NativeQueryBuilder implements Subquery {
     distinct(): this;
     distinctOn(fields: string[]): this;
     onConflict(options: OnConflictClause): OnConflictClause;
-    returning(fields: (string | RawQueryFragment)[]): this;
+    returning(fields: (string | RawQueryFragment | [name: string, type: unknown])[]): this;
     lockMode(lockMode: LockMode, lockTables?: string[]): this;
     comment(comment: string | string[]): this;
     hintComment(comment: string | string[]): this;

package/query/NativeQueryBuilder.js

@@ -30,7 +30,8 @@ export class NativeQueryBuilder {
             tableName = tableName.toRaw();
         }
         if (typeof tableName === 'string') {
-            const alias = options?.alias ? ` as ${this.platform.quoteIdentifier(options.alias)}` : '';
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            const alias = options?.alias ? `${asKeyword}${this.platform.quoteIdentifier(options.alias)}` : '';
             const schema = options?.schema && options.schema !== this.platform.getDefaultSchemaName() ? `${options.schema}.` : '';
             tableName = this.quote(schema + tableName) + alias;
         }
@@ -474,7 +475,8 @@ export class NativeQueryBuilder {
             const parts = id.split(/ as /i);
             const a = this.platform.quoteIdentifier(parts[0]);
             const b = this.platform.quoteIdentifier(parts[1]);
-            return `${a} as ${b}`;
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            return `${a}${asKeyword}${b}`;
         }
         if (id === '*') {
             return id;

package/query/QueryBuilder.d.ts

@@ -682,6 +682,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     from<Name extends string & keyof CTEs, Alias extends string = Name>(target: Name, aliasName?: Alias): SelectQueryBuilder<CTEs[Name], Alias, never, never, never, '*', CTEs>;
     getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
+    protected processReturningStatement(qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -877,7 +878,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * For embeddeds: navigates into flattened embeddeds to return the correct field name.
      */
     protected resolveNestedPath(field: string): string | string[];
-    private init;
+    protected init(type: QueryType, data?: any, cond?: any): this;
     private getQueryBase;
     private applyDiscriminatorCondition;
     /**

package/query/QueryBuilder.js

@@ -775,9 +775,44 @@ export class QueryBuilder {
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
-        this.helper.finalize(this.type, qb, this.mainAlias.meta, this._data, this._returning);
+        this.processReturningStatement(qb, this.mainAlias.meta, this._data, this._returning);
         return (this._query.qb = qb);
     }
+    processReturningStatement(qb, meta, data, returning) {
+        const usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
+        if (!meta || !data || !usesReturningStatement) {
+            return;
+        }
+        // always respect explicit returning hint
+        if (returning && returning.length > 0) {
+            qb.returning(returning.map(field => this.helper.mapper(field, this.type)));
+            return;
+        }
+        if (this.type === QueryType.INSERT) {
+            const returningProps = meta.hydrateProps
+                .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
+                .filter(prop => !(prop.name in data));
+            if (returningProps.length > 0) {
+                qb.returning(Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+            }
+            return;
+        }
+        if (this.type === QueryType.UPDATE) {
+            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
+            if (returningProps.length > 0) {
+                qb.returning(returningProps.flatMap((prop) => {
+                    if (prop.hasConvertToJSValueSQL) {
+                        const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
+                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) +
+                            ' as ' +
+                            this.platform.quoteIdentifier(prop.fieldNames[0]);
+                        return [raw(sql)];
+                    }
+                    return prop.fieldNames;
+                }));
+            }
+        }
+    }
     /**
      * Returns the query with parameters as wildcards.
      */

package/query/QueryBuilderHelper.d.ts

@@ -54,7 +54,6 @@ export declare class QueryBuilderHelper {
     validateQueryOrder<T>(orderBy: QueryOrderMap<T>): void;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>, collation?: string): string[];
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>, collation?: string): string[];
-    finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: InternalField<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
     getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;
     updateVersionProperty(qb: NativeQueryBuilder, data: Dictionary): void;

package/query/QueryBuilderHelper.js

@@ -287,7 +287,8 @@ export class QueryBuilderHelper {
         }
         let sql = method + ' ';
         if (join.nested) {
-            sql += `(${this.platform.quoteIdentifier(table)} as ${this.platform.quoteIdentifier(join.alias)}`;
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            sql += `(${this.platform.quoteIdentifier(table)}${asKeyword}${this.platform.quoteIdentifier(join.alias)}`;
             for (const nested of join.nested) {
                 const { sql: nestedSql, params: nestedParams } = this.createJoinExpression(nested, joins, schema);
                 sql += ' ' + nestedSql;
@@ -296,10 +297,14 @@ export class QueryBuilderHelper {
             sql += `)`;
         }
         else if (join.subquery) {
-            sql += `(${join.subquery}) as ${this.platform.quoteIdentifier(join.alias)}`;
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            sql += `(${join.subquery})${asKeyword}${this.platform.quoteIdentifier(join.alias)}`;
         }
         else {
-            sql += `${this.platform.quoteIdentifier(table)} as ${this.platform.quoteIdentifier(join.alias)}`;
+            sql +=
+                this.platform.quoteIdentifier(table) +
+                    (this.platform.usesAsKeyword() ? ' as ' : ' ') +
+                    this.platform.quoteIdentifier(join.alias);
         }
         const oldAlias = this.alias;
         this.alias = join.alias;
@@ -536,6 +541,12 @@ export class QueryBuilderHelper {
         else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
             parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
+        else if (op === '$re') {
+            const mappedKey = this.mapper(key, type, value[op], null);
+            const processed = this.platform.mapRegExpCondition(mappedKey, value);
+            parts.push(processed.sql);
+            params.push(...processed.params);
+        }
         else if (value[op] instanceof Raw || typeof value[op]?.toRaw === 'function') {
             const query = value[op] instanceof Raw ? value[op] : value[op].toRaw();
             const mappedKey = this.mapper(key, type, query, null);
@@ -669,42 +680,6 @@ export class QueryBuilderHelper {
         }
         return ret;
     }
-    finalize(type, qb, meta, data, returning) {
-        const usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
-        if (!meta || !data || !usesReturningStatement) {
-            return;
-        }
-        // always respect explicit returning hint
-        if (returning && returning.length > 0) {
-            qb.returning(returning.map(field => this.mapper(field, type)));
-            return;
-        }
-        if (type === QueryType.INSERT) {
-            const returningProps = meta.hydrateProps
-                .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
-                .filter(prop => !(prop.name in data));
-            if (returningProps.length > 0) {
-                qb.returning(Utils.flatten(returningProps.map(prop => prop.fieldNames)));
-            }
-            return;
-        }
-        if (type === QueryType.UPDATE) {
-            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
-            if (returningProps.length > 0) {
-                const fields = returningProps.flatMap((prop) => {
-                    if (prop.hasConvertToJSValueSQL) {
-                        const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) +
-                            ' as ' +
-                            this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        return [raw(sql)];
-                    }
-                    return prop.fieldNames;
-                });
-                qb.returning(fields);
-            }
-        }
-    }
     splitField(field, greedyAlias = false) {
         const parts = field.split('.');
         const ref = parts[parts.length - 1].split(':')[1];

package/schema/SchemaComparator.js

@@ -429,7 +429,9 @@ export class SchemaComparator {
             return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]).replace(/"/g, '');
         };
         const compare = (method) => rule(key1, method) === rule(key2, method);
-        return !compare('updateRule') || !compare('deleteRule');
+        // Skip updateRule comparison for platforms that don't support ON UPDATE (e.g., Oracle)
+        const updateRuleDiffers = this.platform.supportsOnUpdate() && !compare('updateRule');
+        return updateRuleDiffers || !compare('deleteRule');
     }
     /**
      * Returns the difference between the columns

package/schema/SchemaHelper.d.ts

@@ -82,6 +82,7 @@ export declare abstract class SchemaHelper {
         managementDbName?: string;
         defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
         defaultDeleteRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
+        tableSpace?: string;
     };
     protected processComment(comment: string): string;
     protected quote(...keys: (string | undefined)[]): string;

package/schema/SchemaHelper.js

@@ -416,6 +416,7 @@ export class SchemaHelper {
         return norm[0].replace('(?)', length != null ? `(${length})` : '');
     }
     getCreateDatabaseSQL(name) {
+        name = this.quote(name);
         // two line breaks to force separate execution
         return `create database ${name};\n\nuse ${name}`;
     }

package/schema/SqlSchemaGenerator.d.ts

@@ -16,6 +16,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         managementDbName?: string;
         defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
         defaultDeleteRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
+        tableSpace?: string;
     };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;

package/schema/SqlSchemaGenerator.js

@@ -372,7 +372,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
      */
     async createDatabase(name, options) {
         name ??= this.config.get('dbName');
-        const sql = this.helper.getCreateDatabaseSQL('' + this.platform.quoteIdentifier(name));
+        const sql = this.helper.getCreateDatabaseSQL(name);
         if (sql) {
             await this.execute(sql);
         }