@egi/smart-db 2.3.1 → 2.3.2

package/src/smart-db.ts

@@ -0,0 +1,854 @@
+import _ from "lodash";
+import {AbstractModel} from "./models/abstract-model";
+import {SmartDbDictionary} from "./models/smart-db-dictionary";
+import {SmartDbLogModel} from "./models/smart-db-log-model";
+import {SmartDbVersionViewModel} from "./models/smart-db-version-view-model";
+import {IN, smartDbToDate, toSmartDbDate, toSmartDbTimestamp} from "./smart-db-globals";
+import {
+    AbstractModelGlobals, AttributeInfo, FieldNamingStyle, GenericModelData, IndexedGenericModelData, KeyValueList, ModelAttributeMap, SectionDescription,
+    SmartDbApi, SmartDbConnector, SmartDbDatabase, SmartDbOptions, SmartDbRunResult, SmartDbSqlComparison, SmartDbSqlOptions, SmartDbTableInfo,
+    SqlFieldDescriptor, SqlFieldOperationType, SqlLimit, SqlOperation, SqlOperationType, SqlOrderBy, SqlUpdateValues, SqlValueType, SqlWhere
+} from "./smart-db-interfaces";
+import {SmartDbLog, SmartDbLogLocation} from "./smart-db-log";
+import {SmartDbSqlBuildData} from "./smart-db-sql-build-data";
+import {SmartDbUpgradeManager} from "./smart-db-upgrade-manager";
+
+export abstract class SmartDb implements SmartDbApi {
+    public abstract getDatabaseType(): string;
+
+    // noinspection JSUnusedGlobalSymbols
+    public abstract hasConcurrentTransactions(): boolean;
+
+    public abstract exists<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), type?: "view" | "table" | "index", indexTableName?: string): Promise<boolean>;
+
+    public abstract existsSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), type?: "view" | "table" | "index", indexTableName?: string): boolean;
+
+    public abstract exec(script: string): Promise<void>;
+
+    public abstract execSync(script: string): SmartDbDatabase | false;
+
+    // noinspection JSUnusedGlobalSymbols
+    public abstract close(): Promise<void>;
+
+    // noinspection JSUnusedGlobalSymbols
+    public abstract closeSync(): boolean;
+
+    public abstract getDbQuote(): string;
+
+    public abstract getTableInfo(table: string): Promise<SmartDbTableInfo>;
+
+    public abstract getDbConnector(): string | SmartDbConnector;
+
+    protected abstract statementRun(buildData: SmartDbSqlBuildData): Promise<SmartDbRunResult>;
+
+    protected abstract statementRunSync(buildData: SmartDbSqlBuildData): SmartDbRunResult;
+
+    protected abstract statementGet(buildData: SmartDbSqlBuildData): Promise<any>;
+
+    protected abstract statementGetSync(buildData: SmartDbSqlBuildData): any;
+
+    protected abstract statementGetAll(buildData: SmartDbSqlBuildData): Promise<any[]>;
+
+    protected abstract statementGetAllSync(buildData: SmartDbSqlBuildData): any[];
+
+    protected db: SmartDbDatabase;
+    protected dbConnector: SmartDbConnector;
+    protected lastError: Error;
+    protected lastBuildData: SmartDbSqlBuildData;
+    protected smartDbLog: SmartDbLog;
+    private dictionaries: any[] = [];
+
+    protected constructor(dbConnector: SmartDbConnector) {
+        this.dbConnector = dbConnector;
+        this.smartDbLog = new SmartDbLog(this);
+    }
+
+    public initDb(appOptions: SmartDbOptions): Promise<SmartDbVersionViewModel[]> {
+        return new Promise<SmartDbVersionViewModel[]>((resolve, reject) => {
+            this.dictionaries.push(SmartDbDictionary);
+
+            const upgradeManager = new SmartDbUpgradeManager(this);
+
+            // ES module compatibility
+            let dirname: string;
+            if (import.meta && import.meta.url) {
+                dirname = import.meta.url.replace(/file:\/\//, "").replace(/\/[^/]*$/, "");
+            } else {
+                dirname = __dirname;
+            }
+
+            const coreOptions: SmartDbOptions = {
+                module: "smart-db-core",
+                sqlFilesDirectory: dirname + "/assets/" + this.getDatabaseType()
+            };
+
+            upgradeManager.prepareDatabase(coreOptions).then((coreVersion) => {
+                this.exists(SmartDbLogModel).then((exists) => {
+                    this.smartDbLog.setDbLogging(exists);
+
+                    upgradeManager.prepareDatabase(appOptions).then((version) => {
+                        resolve([coreVersion, version]);
+                    }, (err) => {
+                        reject(err);
+                    });
+                });
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+
+    public getLogger(): SmartDbLog {
+        return this.smartDbLog;
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public getDb(): SmartDbDatabase {
+        return this.db;
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public getLastBuildData(): SmartDbSqlBuildData {
+        return this.lastBuildData;
+    }
+
+    // noinspection FunctionNamingConventionJS
+    public get<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), options: SmartDbSqlOptions<T, D>): Promise<(T | D)[] | T | D | SqlValueType | IndexedGenericModelData<T, D> | string | string[]> {
+        return new Promise<(T | D)[] | T | D | SqlValueType | IndexedGenericModelData<T, D> | string | string[]>((resolve, reject) => {
+            if (!options) {
+                options = {};
+            }
+
+            const buildData = this.buildSelectStatement(modelClass, options);
+
+            if (options.firstOnly || options.count) {
+                this.statementGet(buildData).then((row) => {
+                    resolve(this.prepareResultRow(modelClass, row, options));
+                }).catch((err) => {
+                    reject(err);
+                });
+            } else {
+                this.statementGetAll(buildData).then((rows) => {
+                    resolve(this.prepareResultRows(modelClass, rows, options));
+                }).catch((err) => {
+                    reject(err);
+                });
+            }
+        });
+    }
+
+    // noinspection FunctionNamingConventionJS
+    public getSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), options: SmartDbSqlOptions<T, D>): (T | D)[] | T | D | SqlValueType | IndexedGenericModelData<T, D> | string | string[] | false {
+        return this.saveExecute(() => {
+            if (!options) {
+                options = {};
+            }
+
+            const buildData = this.buildSelectStatement(modelClass, options);
+
+            let result: (T | D)[] | T | D | SqlValueType | IndexedGenericModelData<T, D> | string | string[];
+
+            if (options.firstOnly || options.count) {
+                const row = this.statementGetSync(buildData);
+                result = this.prepareResultRow(modelClass, row, options);
+            } else {
+                const rows = this.statementGetAllSync(buildData);
+                result = this.prepareResultRows(modelClass, rows, options);
+            }
+
+            return result;
+        });
+    }
+
+    public getFirst<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy): Promise<T> {
+        return this.get(modelClass, {
+            firstOnly: true,
+            where: where,
+            fields: fields,
+            orderBy: orderBy
+        }) as Promise<T>;
+    }
+
+    public getFirstSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy): T | false {
+        return this.getSync(modelClass, {
+            firstOnly: true,
+            where: where,
+            fields: fields,
+            orderBy: orderBy
+        }) as T;
+    }
+
+    public getAll<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy, limit?: SqlLimit): Promise<T[]> {
+        return this.get(modelClass, {
+            where: where,
+            fields: fields,
+            orderBy: orderBy,
+            limit: limit
+        }) as Promise<T[]>;
+    }
+
+    public getAllSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy, limit?: SqlLimit): T[] | false {
+        return this.getSync(modelClass, {
+            where: where,
+            fields: fields,
+            orderBy: orderBy,
+            limit: limit
+        }) as T[] | false;
+    }
+
+    public delete<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere): Promise<number> {
+        return new Promise<number>((resolve, reject) => {
+            const buildData = this.buildDeleteStatement(modelClass, where);
+            this.statementRun(buildData).then((runResult) => {
+                if (runResult) {
+                    resolve(runResult.changes);
+                } else {
+                    reject(this.getLastError());
+                }
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+
+    public deleteSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere): number | false {
+        return this.saveExecute(() => {
+            const buildData = this.buildDeleteStatement(modelClass, where);
+            const runResult = this.statementRunSync(buildData);
+            return (<any>runResult).changes;
+        });
+    }
+
+    public update<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T, where?: SqlWhere): Promise<number> {
+        return new Promise<number>((resolve, reject) => {
+            const buildData = this.buildUpdateStatement(modelClass, values, where);
+            this.statementRun(buildData).then((runResult) => {
+                if (runResult) {
+                    resolve(runResult.changes);
+                } else {
+                    reject(this.getLastError());
+                }
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+
+    public updateSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T, where?: SqlWhere): number | false {
+        return this.saveExecute(() => {
+            const buildData = this.buildUpdateStatement(modelClass, values, where);
+            const runResult = this.statementRunSync(buildData);
+            return runResult.changes;
+        });
+    }
+
+    public insert<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T): Promise<number> {
+        return new Promise<number>((resolve, reject) => {
+            const buildData = this.buildInsertStatement(modelClass, values);
+            this.statementRun(buildData).then((runResult) => {
+                if (runResult) {
+                    resolve(runResult.lastId as number);
+                } else {
+                    reject(this.getLastError());
+                }
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+
+    public insertSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T): number | false {
+        return this.saveExecute(() => {
+            const buildData = this.buildInsertStatement(modelClass, values);
+            const runResult = this.statementRunSync(buildData);
+            return runResult.lastId;
+        });
+    }
+
+    public getLastError(): Error {
+        return this.lastError;
+    }
+
+    public buildSelectStatement<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), options: SmartDbSqlOptions<T, D>): SmartDbSqlBuildData {
+        if (!options) {
+            options = {};
+        }
+
+        const buildData = this.buildSelectSectionStatement(modelClass, options);
+
+        _.forEach(["union", "minus", "intersect"], (sectionName) => {
+            let section: SectionDescription<T, D>[] = _.get(options, sectionName) as SectionDescription<T, D>[];
+            if (section) {
+                if (!_.isArray(section)) {
+                    section = [section];
+                }
+
+                _.forEach(section, (sectionElement) => {
+                    const sectionBuildData = this.buildSelectSectionStatement(sectionElement.model, sectionElement);
+                    buildData.sql += " " + sectionName.toUpperCase() + " ";
+                    buildData.append(sectionBuildData);
+                });
+            }
+        });
+
+        if (options.orderBy) {
+            buildData.sql += " ORDER BY ";
+
+            const orderBy = _.isString(options.orderBy) ? options.orderBy.split(/ *, */) : options.orderBy;
+
+            buildData.sql += orderBy.map((field) => {
+                let sortDirection = "";
+                const match = field.match(/^(\w*) (asc|desc)$/i);
+                if (match) {
+                    field = match[1];
+                    sortDirection = match[2].toUpperCase();
+                }
+
+                field = this.translateFieldName(modelClass, field);
+
+                if (sortDirection) {
+                    field += " " + sortDirection;
+                }
+
+                return field;
+            }).join(", ");
+        }
+
+        if (options.limit) {
+            if (options.limit.limit) {
+                buildData.sql += " LIMIT " + options.limit.limit.toString();
+            }
+
+            if (options.limit.offset) {
+                buildData.sql += " OFFSET " + options.limit.offset.toString();
+            }
+        }
+
+        this.lastBuildData = buildData;
+
+        return buildData;
+    }
+
+    public toDate(d: Date | number | string): Date | null {
+        return smartDbToDate(d);
+    }
+
+    public toDbTimestamp(d: Date | number): string {
+        return toSmartDbTimestamp(d);
+    }
+
+    public toDbDate(d: Date | number): string {
+        return toSmartDbDate(d);
+    }
+
+    protected buildWhere<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where: SqlWhere, op?: string): SmartDbSqlBuildData {
+        const whereClause = new SmartDbSqlBuildData();
+
+        if (where && _.keys(where).length > 0) {
+            if (!op) {
+                op = "AND";
+                whereClause.sql += " WHERE ";
+            }
+
+            // noinspection FunctionWithMultipleReturnPointsJS,FunctionTooLongJS,OverlyComplexFunctionJS
+            whereClause.sql += _.map(where, (value, key) => {
+                const upperKey = key.toUpperCase();
+                if (upperKey == "AND" || upperKey == "OR") {
+                    let subClauseSql = "";
+                    const subValues: any[] = _.isArray(value) ? value : [value];
+                    subValues.forEach((subValue, idx) => {
+                        const subValueClause = this.buildWhere(modelClass, subValue, upperKey);
+                        if (idx > 0) {
+                            subClauseSql += " " + upperKey + " ";
+                        }
+                        subClauseSql += subValueClause.sql;
+                        whereClause.values = _.concat(whereClause.values, subValueClause.values);
+                    });
+
+                    subClauseSql = "(" + subClauseSql + ")";
+
+                    return subClauseSql;
+                } else if (upperKey == "EXPRESSION") {
+                    let compares: string[] = [];
+                    _.forEach(<SmartDbSqlComparison[]>value, (comparison: SmartDbSqlComparison) => {
+                        const compareField = this.prepareField(modelClass, comparison.compare, whereClause.values);
+                        const withField = this.prepareField(modelClass, comparison.with, whereClause.values);
+
+                        let compareOp: SqlOperationType;
+                        if (_.isString(comparison.operation) && (<any>SqlOperationType)[comparison.operation]) {
+                            compareOp = (<any>SqlOperationType)[comparison.operation];
+                        } else {
+                            compareOp = comparison.operation || SqlOperationType.EQ;
+                        }
+
+                        compares.push(`${compareField} ${compareOp} ${withField}`);
+                    });
+
+                    return compares.join(" " + op + " ");
+                } else {
+                    let checkFieldName = true;
+                    let compareWith: string;
+
+                    if (_.isArray(value)) {
+                        value = IN(value as SqlValueType[]);
+                    }
+
+                    if (_.isObject(value)) {
+                        const sqlOperation = value as SqlOperation;
+                        if (_.isString(sqlOperation.operation) && (<any>SqlOperationType)[sqlOperation.operation]) {
+                            sqlOperation.operation = (<any>SqlOperationType)[sqlOperation.operation];
+                        }
+
+                        switch (sqlOperation.operation) {
+                            case SqlOperationType.IN:
+                                const placeholders = new Array((<SqlValueType[]>sqlOperation.value).length);
+                                placeholders.fill("?");
+                                compareWith = SqlOperationType.IN + " (" + placeholders.join(", ") + ")";
+                                whereClause.values = _.concat(whereClause.values, sqlOperation.value);
+                                break;
+
+                            case SqlOperationType.IS_NULL:
+                            case SqlOperationType.IS_NOT_NULL:
+                                compareWith = sqlOperation.operation;
+                                break;
+
+                            case SqlOperationType.LITERAL:
+                                key = sqlOperation.key;
+
+                                const literalOperation: SqlOperationType = sqlOperation.literalOperation || SqlOperationType.EQ;
+
+                                if (literalOperation == SqlOperationType.IN) {
+                                    const literalPlaceholders = new Array((<SqlValueType[]>sqlOperation.value).length);
+                                    literalPlaceholders.fill("?");
+                                    compareWith = SqlOperationType.IN + " (" + literalPlaceholders.join(", ") + ")";
+                                    whereClause.values = _.concat(whereClause.values, sqlOperation.value);
+                                } else if (_.isUndefined(sqlOperation.value)) {
+                                    compareWith = literalOperation;
+                                } else {
+                                    compareWith = literalOperation + " ?";
+                                    whereClause.values.push(this.makeDbValue(sqlOperation.value as SqlValueType));
+                                }
+                                checkFieldName = false;
+                                break;
+
+                            default:
+                                compareWith = sqlOperation.operation + " ?";
+                                whereClause.values.push(this.makeDbValue(sqlOperation.value as SqlValueType));
+                                break;
+                        }
+                    } else {
+                        if (value === null) {
+                            compareWith = SqlOperationType.IS_NULL;
+                        } else if (value === undefined) {
+                            // this skips this value without breaking the structure
+                            key = "1";
+                            compareWith = "= 1";
+                            checkFieldName = false;
+                        } else {
+                            if (_.isString(value) && value.match(/[%_]/)) {
+                                compareWith = SqlOperationType.LIKE + " ?";
+                            } else {
+                                compareWith = SqlOperationType.EQ + " ?";
+                            }
+                            whereClause.values.push(this.makeDbValue(value));
+                        }
+                    }
+
+                    let result: string;
+                    if (checkFieldName) {
+                        result = this.translateFieldName(modelClass, key) + " " + compareWith;
+                    } else {
+                        result = key + " " + compareWith;
+                    }
+
+                    return result;
+                }
+            }).join(" " + op + " ");
+        }
+
+        return whereClause;
+    }
+
+    protected buildDeleteStatement<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere): SmartDbSqlBuildData {
+        const tableName = this.getTableName(modelClass);
+
+        const buildData = new SmartDbSqlBuildData("DELETE FROM");
+        buildData.sql += " " + tableName;
+
+        if (where) {
+            buildData.append(this.buildWhere(modelClass, where));
+        }
+
+        this.lastBuildData = buildData;
+
+        return buildData;
+    }
+
+    protected buildUpdateStatement<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T, where?: SqlWhere): SmartDbSqlBuildData {
+        const tableName = this.getTableName(modelClass);
+
+        const buildData = new SmartDbSqlBuildData("UPDATE");
+        buildData.sql += " " + tableName + " SET ";
+
+        const keys: string[] = [];
+
+        if (values instanceof AbstractModel) {
+            values = values.getPlainObject(FieldNamingStyle.Database);
+        }
+
+        _.forOwn(values, (value, key) => {
+            keys.push(this.translateFieldName(modelClass, key) + " = ?");
+            buildData.values.push(this.makeDbValue(value));
+        });
+
+        buildData.sql += keys.join(", ");
+
+        if (where) {
+            buildData.append(this.buildWhere(modelClass, where));
+        }
+
+        this.lastBuildData = buildData;
+
+        return buildData;
+    }
+
+    protected buildInsertStatement<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T): SmartDbSqlBuildData {
+        const tableName = this.getTableName(modelClass);
+
+        const buildData = new SmartDbSqlBuildData("INSERT");
+        buildData.sql += " INTO " + tableName;
+
+        const fields: string[] = [];
+
+        if (values instanceof AbstractModel) {
+            values = values.getPlainObject(FieldNamingStyle.Database);
+        }
+
+        _.forOwn(values, (value, field) => {
+            field = this.translateFieldName(modelClass, field);
+            fields.push(field);
+            buildData.values.push(this.makeDbValue(value));
+        });
+
+        const placeholders = new Array(fields.length);
+        placeholders.fill("?");
+
+        buildData.sql += " (" + fields.join(", ") + ") VALUES (" + placeholders.join(", ") + ")";
+
+        this.lastBuildData = buildData;
+
+        return buildData;
+    }
+
+    // noinspection OverlyComplexFunctionJS,FunctionTooLongJS
+    protected prepareFieldValue<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), fieldOperation: SqlFieldDescriptor): string {
+        let value: string = "<undefined>";
+
+        switch (fieldOperation.operation) {
+            case SqlFieldOperationType.FIELD:
+                value = this.translateFieldName(modelClass, fieldOperation.value as string);
+                break;
+
+            case SqlFieldOperationType.VALUE:
+                if (fieldOperation.value === null) {
+                    value = "NULL";
+                } else if (fieldOperation.literal) {
+                    value = fieldOperation.value as string;
+                } else if (_.isString(fieldOperation.value)) {
+                    // quote if not numeric
+                    if (isNaN(parseFloat(fieldOperation.value)) || !isFinite(<any>fieldOperation.value)) {
+                        value = "'" + fieldOperation.value + "'";
+                    }
+                } else if (_.isNumber(fieldOperation.value)) {
+                    value = fieldOperation.value.toString();
+                } else if (_.isBoolean(fieldOperation.value)) {
+                    value = fieldOperation.value ? "1" : "0";
+                } else if (_.isDate(fieldOperation.value)) {
+                    value = "'" + fieldOperation.value.toISOString().substr(0, 23).replace("T", " ") + "'";
+                } else {
+                    console.error("unhandled field data type", typeof fieldOperation.value, fieldOperation.value);
+                }
+
+                break;
+
+            case SqlFieldOperationType.COUNT:
+                if (_.isArray(fieldOperation.value)) {
+                    value = "COUNT(" + fieldOperation.value.join(",") + ")";
+                } else {
+                    value = "COUNT(" + (fieldOperation.value || "") + ")";
+                }
+                break;
+
+            case SqlFieldOperationType.COALESCE:
+                const values = _.isArray(fieldOperation.value) ? fieldOperation.value : [fieldOperation.value];
+                const fieldValues = this.buildFieldList(modelClass, values);
+                value = "COALESCE(" + fieldValues.join(",") + ")";
+                break;
+        }
+
+        if (fieldOperation.alias) {
+            const dbQuote = this.getDbQuote();
+            value += ` as ${dbQuote}${fieldOperation.alias}${dbQuote}`;
+        }
+
+        return value;
+    }
+
+    protected prepareField<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), field: SqlValueType | SqlFieldDescriptor, values?: SqlValueType[]): string {
+        let dbField: string;
+
+        if (field === null) {
+            dbField = "NULL";
+        } else if (_.isString(field)) {
+            const matches = field.match(/^'(.*)'$/);
+            if (matches) {
+                if (values) {
+                    dbField = "?";
+                    values.push(matches[1]);
+                } else {
+                    dbField = field;
+                }
+            } else {
+                dbField = this.translateFieldName(modelClass, field);
+            }
+        } else if ((<SqlFieldDescriptor>field).operation) {
+            dbField = this.prepareFieldValue(modelClass, <SqlFieldDescriptor>field);
+        } else if (values) {
+            dbField = "?";
+            values.push(field as SqlValueType);
+        } else {
+            dbField = this.makeArgumentDbValue(field as SqlValueType).toString();
+        }
+
+        return dbField;
+    }
+
+    protected buildFieldList<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), fields: (SqlValueType | SqlFieldDescriptor)[]): string[] {
+        const dbFields: string[] = [];
+
+        _.forEach(fields, (field) => {
+            dbFields.push(this.prepareField(modelClass, field));
+        });
+
+        return dbFields;
+    }
+
+    // noinspection OverlyComplexFunctionJS
+    protected buildSelectSectionStatement<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), options: SmartDbSqlOptions<T, D>): SmartDbSqlBuildData {
+        const tableName = this.getTableName(modelClass);
+
+        let fields: (string | SqlFieldDescriptor)[];
+        if (_.isArray(options.fields)) {
+            fields = options.fields;
+        } else if (_.isString(options.fields)) {
+            const fieldsString = options.fields.trim();
+            if (fieldsString === "" || fieldsString == "*") {
+                fields = [];
+            } else {
+                fields = fieldsString.split(/,/);
+            }
+        } else if (options.fields && options.fields.operation) {
+            fields = [options.fields];
+        } else {
+            fields = [];
+        }
+
+        let fieldString: string;
+        if (fields.length > 0) {
+            let dbFields = this.buildFieldList(modelClass, fields);
+            fieldString = dbFields.join(", ");
+        } else {
+            fieldString = "*";
+        }
+
+        if (options.distinct) {
+            fieldString = "DISTINCT " + fieldString;
+        }
+        if (options.count) {
+            fieldString = `COUNT(${fieldString})`;
+        }
+
+        const buildData = new SmartDbSqlBuildData(`SELECT ${fieldString} FROM ${tableName}`);
+
+        if (options.where) {
+            buildData.append(this.buildWhere(modelClass, options.where));
+        }
+
+        if (options.groupBy) {
+            buildData.sql += " GROUP BY ";
+
+            const groupBy = _.isArray(options.groupBy) ? options.groupBy : [options.groupBy];
+
+            buildData.sql += groupBy.map((field) => {
+                return this.translateFieldName(modelClass, field);
+            }).join(", ");
+        }
+
+        return buildData;
+    }
+
+    protected translateFieldName<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new() => T), field: string): string {
+        if (_.isString(modelClass)) {
+            const modelClassName = modelClass;
+
+            let done = false;
+            _.forEach(this.dictionaries, (dictionary) => {
+                if (dictionary.models && dictionary.models[modelClassName]) {
+                    modelClass = dictionary.models[modelClassName].cls;
+                    done = true;
+                }
+
+                return !done;
+            });
+        }
+
+        if (!_.isString(modelClass)) {
+            const attributeMap: ModelAttributeMap = (<AbstractModelGlobals<T, D>><unknown>modelClass).attributeMap;
+            const info: AttributeInfo = attributeMap[field];
+            if (info) {
+                if (info.alias) {
+                    field = info.alias;
+                }
+            } else {
+                const tableName = (<AbstractModelGlobals<T, D>><unknown>modelClass).getTableName();
+                this.lastError = new Error(`unknown field '${field}' in table '${tableName}'`);
+                this.smartDbLog.logError(SmartDbLogLocation.Database, "translateFieldName", this.lastError);
+            }
+        }
+
+        return field;
+    }
+
+    // noinspection JSMethodCanBeStatic
+    protected makeDbValue(value: SqlValueType): SqlValueType {
+        if (_.isBoolean(value)) {
+            value = value ? 1 : 0;
+        } else if (_.isDate(value)) {
+            value = toSmartDbDate(value);
+        }
+
+        return value;
+    }
+
+    // noinspection JSMethodCanBeStatic
+    protected makeArgumentDbValue(value: SqlValueType): SqlValueType {
+        if (_.isBoolean(value)) {
+            value = value ? 1 : 0;
+        } else if (_.isDate(value)) {
+            value = `'${toSmartDbDate(value)}'`;
+        } else if (_.isString(value)) {
+            value = `'${value}'`;
+        }
+
+        return value;
+    }
+
+    protected saveExecute<T>(fn: () => T): T | false {
+        let ret: T | false;
+
+        try {
+            ret = fn();
+        } catch (error) {
+            this.lastError = error instanceof Error ? error : new Error(error || "Unknown error");
+            this.smartDbLog.logFatal(SmartDbLogLocation.Database, "saveExecute-catch", this.lastError);
+            ret = false;
+        }
+
+        return ret;
+    }
+
+    private prepareResultRow<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), rows: any, options: SmartDbSqlOptions<T, D>): T | D | SqlValueType {
+        let result: D | SqlValueType | T;
+
+        if (options.indexedBy) {
+            this.smartDbLog.logWarning(SmartDbLogLocation.Database, "AbstractModel.get", "option 'indexedBy' not supported without 'all'");
+        }
+
+        if (rows) {
+            if (options.count) {
+                result = parseInt(_.values(rows)[0], 10);
+            } else if (options.collapseRow) {
+                result = _.values(rows).join(",");
+            } else {
+                const modelClassStatics = <AbstractModelGlobals<T, D>><unknown>modelClass;
+                result = modelClassStatics.from(rows) as T;
+            }
+        }
+
+        return result;
+    }
+
+    private prepareResultRows<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), rows: (T | D)[], options: SmartDbSqlOptions<T, D>): (T | D)[] | T | D | IndexedGenericModelData<T, D> | string | string[] {
+        let result: (T | D)[] | T | D | IndexedGenericModelData<T, D> | string | string[];
+
+        if (!options.indexedBy && !options.collapseRow && _.isString(modelClass)) {
+            result = rows;
+        } else {
+            const modelClassStatics = <AbstractModelGlobals<T, D>><unknown>modelClass;
+
+            if (options.indexedBy) {
+                result = {};
+            } else {
+                result = new Array(rows.length);
+            }
+
+            _.forEach(rows as D[], (row, i: number) => {
+                const objectRow = modelClassStatics.from ? modelClassStatics.from(row) : null;
+
+                let indexColumn: string = null;
+                if (options.indexedBy) {
+                    if (objectRow) {
+                        indexColumn = objectRow.getValue(options.indexedBy) as string;
+                    } else {
+                        indexColumn = row[options.indexedBy] as string;
+                    }
+                }
+
+                if (options.collapseRow) {
+                    const collapsedRow: string = _.values(row).join(",");
+                    if (indexColumn) {
+                        (<KeyValueList>result)[indexColumn] = collapsedRow;
+                    } else {
+                        (<string[]>result)[i] = collapsedRow;
+                    }
+                } else {
+                    if (indexColumn) {
+                        (<IndexedGenericModelData<T, D>>result)[indexColumn] = objectRow || row;
+                    } else {
+                        (<IndexedGenericModelData<T, D>>result)[i] = objectRow || row;
+                    }
+                }
+            });
+        }
+
+        return result;
+    }
+
+    private getTableName<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T)): string {
+        let tableName: string;
+
+        if (_.isString(modelClass)) {
+            let modelClassName = modelClass;
+
+            _.forEach(this.dictionaries, (dictionary) => {
+                if (dictionary.models && dictionary.models[modelClassName]) {
+                    tableName = dictionary.models[modelClassName].cls.getTableName();
+                }
+
+                return !tableName;
+            });
+
+            if (!tableName) {
+                tableName = modelClassName;
+            }
+        } else if (modelClass && (<AbstractModelGlobals<T, D>><unknown>modelClass).getTableName) {
+            tableName = (<AbstractModelGlobals<T, D>><unknown>modelClass).getTableName();
+        } else {
+            throw new Error(`unknown model: ${modelClass}`);
+        }
+
+
+        return tableName;
+    }
+}
+