pogi 3.0.0-beta → 3.0.0-beta5

package/src/pgUtils.ts

@@ -1,290 +0,0 @@
-import { QueryOptions, IQueryAble } from "./queryAbleInterface";
-import { ResultFieldType } from "./pgDbInterface";
-import { FieldType } from "./pgDb";
-import { PgDbLogger } from "./pgDbLogger";
-import { IPgTable } from "./pgTableInterface";
-import * as _ from 'lodash';
-import util = require('util');
-import * as pg from 'pg';
-
-const NAMED_PARAMS_REGEXP = /(?:^|[^:]):(!?[a-zA-Z0-9_]+)/g;    // do not convert "::type cast"
-const ASC_DESC_REGEXP = /^\s*(.+?)(?:\s+(asc|desc))?\s*$/i;
-
-export let pgUtils = {
-
-    logError(logger: PgDbLogger, options: { error?: string | Error, sql: string, params: any, connection?: pg.PoolClient | null }) {
-        let { error, sql, params, connection } = options;
-        logger.error(error, sql, util.inspect(logger.paramSanitizer ? logger.paramSanitizer(params) : params, false, null), connection ? connection.processID : null);
-    },
-
-    quoteFieldNameInsecure(f: string) {
-        return f.indexOf('"') == -1 && f.indexOf('(') == -1 ? '"' + f + '"' : f;
-    },
-
-    quoteFieldName(f: string) {
-        if (typeof f === 'string' && f.length) {
-            return `"${f
-                .replace(/^\s*"*/, '') // trim "
-                .replace(/"*\s*$/, '')
-                .replace(/"/g, '""')}"`;
-        } else {
-            throw new Error(`Invalid field: ${f}`);
-        }
-    },
-
-    quoteFieldNameOrPositionInsecure(f: string | number): string {
-        if (Number.isInteger(+f)) {
-            if (!Number.isInteger(+f) || +f < 1) throw new Error(`Invalid field: ${f}`);
-            return '' + f;
-        } else if (typeof f === 'string' && f.length) {
-            return f.indexOf('"') == -1 && f.indexOf('(') == -1 ? '"' + f + '"' : f;
-        } else {
-            throw new Error(`Invalid field: ${f}`);
-        }
-    },
-
-    /** ex. for order by column position can be use, which needs no quote  */
-    quoteFieldNameOrPosition(f: string | number): string {
-        if (Number.isInteger(+f)) {
-            if (!Number.isInteger(+f) || +f < 1) throw new Error(`Invalid field: ${f}`);
-            return '' + f;
-        } else if (typeof f === 'string' && f.length) {
-            return `"${f
-                .replace(/^\s*"*\s*/, '') // trim "
-                .replace(/\s*"*\s*$/, '')
-                .replace(/"/g, '""')}"`;
-        } else {
-            throw new Error(`Invalid field: ${f}`);
-        }
-    },
-    /**
-     * https://www.postgresql.org/docs/current/functions-json.html 
-     * column->'a' , 
-     * column -> 3
-     */
-    quoteFieldNameJsonbOrPosition(f: string | number): string {
-        // treat numeric json keys as array indices, otherwise quote it
-        if (Number.isInteger(+f)) {
-            return '' + f;
-        } if (typeof f === 'string' && f.length) {
-            return `'${f
-                .replace(/^\s*'*/, '') // trim "
-                .replace(/'*\s*$/, '')
-                .replace(/'/g, "''")}'`;
-        } else {
-            throw new Error(`Invalid field: ${f}`);
-        }
-    },
-
-    processQueryFields<T>(options: QueryOptions, pgTable?: IPgTable<T>): string {
-        let escapeColumns = ((pgTable?.db.config.forceEscapeColumns === true || pgTable?.db.config.forceEscapeColumns?.select === true) && options.forceEscapeColumns?.select !== false && options.forceEscapeColumns !== false) ||
-            options.forceEscapeColumns === true || options.forceEscapeColumns?.select;
-
-        let s = options && options.distinct ? ' DISTINCT ' : ' ';
-        if (options && options.fields) {
-            if (Array.isArray(options.fields)) {
-                if (escapeColumns) {
-                    return s + options.fields.map(pgUtils.quoteFieldName).join(', ');
-                }
-                return s + options.fields.map(pgUtils.quoteFieldNameInsecure).join(', ');
-            } else {
-                return s + options.fields;
-            }
-        } else {
-            return s + ' *';
-        }
-    },
-
-    /**
-     * :named -> $1 (not works with DDL (schema, table, column))
-     * :!named -> "value" (for DDL (schema, table, column))
-     * do not touch ::type cast
-     */
-    processNamedParams(sql: string, params: Object) {
-        let sql2 = [];
-        let params2 = [];
-
-        let p = NAMED_PARAMS_REGEXP.exec(sql);
-        let lastIndex = 0;
-        while (p) {
-            let ddl = false;
-            let name = p[1];
-            if (name[0] == '!') {
-                name = name.slice(1);
-                ddl = true;
-            }
-
-            if (!(name in params)) {
-                throw new Error(`No ${p[1]} in params (keys: ${Object.keys(params)})`);
-            }
-            sql2.push(sql.slice(lastIndex, NAMED_PARAMS_REGEXP.lastIndex - p[1].length - 1));
-
-            if (ddl) {
-                sql2.push(pgUtils.quoteFieldName(params[name]));
-            } else {
-                params2.push(params[name]);
-                sql2.push('$' + params2.length);
-            }
-            lastIndex = NAMED_PARAMS_REGEXP.lastIndex;
-            p = NAMED_PARAMS_REGEXP.exec(sql);
-        }
-        sql2.push(sql.slice(lastIndex));
-
-        return {
-            sql: sql2.join(''),
-            params: params2
-        }
-    },
-
-    handleColumnEscapeGroupBy<T>(options: QueryOptions, pgTable?: IPgTable<T>): string {
-        if (!options.groupBy) return '';
-        let escapeColumns = ((pgTable?.db.config.forceEscapeColumns === true || pgTable?.db.config.forceEscapeColumns?.groupBy === true) && options.forceEscapeColumns?.groupBy !== false && options.forceEscapeColumns !== false) ||
-            options.forceEscapeColumns === true || options.forceEscapeColumns?.groupBy;
-
-        if (escapeColumns) {
-            if (Array.isArray(options.groupBy)) {
-                return ' GROUP BY ' + options.groupBy.map(pgUtils.quoteFieldNameOrPosition).join(',');
-            } else {
-                return ' GROUP BY ' + pgUtils.quoteFieldNameOrPosition(options.groupBy);
-            }
-        } else {
-            if (Array.isArray(options.groupBy)) {
-                return ' GROUP BY ' + options.groupBy.map(pgUtils.quoteFieldNameOrPositionInsecure).join(',');
-            } else {
-                return ' GROUP BY ' + pgUtils.quoteFieldNameOrPositionInsecure(options.groupBy);
-            }
-        }
-    },
-
-    handleColumnEscapeOrderBy<T>(options: QueryOptions, pgTable: IPgTable<T>): string {
-        if (!options.orderBy) return '';
-        let sql = '';
-        let escapeColumns = ((pgTable?.db.config.forceEscapeColumns === true || pgTable?.db.config.forceEscapeColumns?.orderBy === true) && options.forceEscapeColumns?.orderBy !== false && options.forceEscapeColumns !== false) ||
-            options.forceEscapeColumns === true || options.forceEscapeColumns?.orderBy;
-
-        let orderBy = typeof options.orderBy === 'string' ? options.orderBy.split(',') : options.orderBy;
-        if (Array.isArray(orderBy)) {
-            let orderBy2: string[];
-
-            if (escapeColumns) {
-                orderBy2 = orderBy.map(v => {
-                    if (typeof v === 'number') return pgUtils.quoteFieldNameOrPosition(v);
-                    else if (typeof v !== 'string' || !v.length) throw new Error(`Invalid orderBy: ${v}`);
-                    if (v[0] == '+') return pgUtils.quoteFieldNameOrPosition(v.slice(1));
-                    if (v[0] == '-') return pgUtils.quoteFieldNameOrPosition(v.slice(1)) + ' desc';
-                    let o = ASC_DESC_REGEXP.exec(v);
-                    if (!o) throw new Error(`Invalid orderBy: ${v}`);
-                    return `${pgUtils.quoteFieldNameOrPosition(o[1])} ${o[2] ?? ''}`;
-                });
-            } else {
-                orderBy2 = orderBy.map(v => {
-                    if (typeof v === 'number') return pgUtils.quoteFieldNameOrPositionInsecure(v);
-                    else if (typeof v !== 'string' || !v.length) throw new Error(`Invalid orderBy: ${v}`);
-                    if (v[0] == '+') return pgUtils.quoteFieldNameOrPositionInsecure(v.slice(1));
-                    if (v[0] == '-') return pgUtils.quoteFieldNameOrPositionInsecure(v.slice(1)) + ' desc';
-                    let o = ASC_DESC_REGEXP.exec(v);
-                    if (!o) throw new Error(`Invalid orderBy: ${v}`);
-                    return `${pgUtils.quoteFieldNameOrPositionInsecure(o[1])} ${o[2] ?? ''}`;
-                });
-            }
-            sql += ' ORDER BY ' + orderBy2.join(',');
-        } else {
-            throw new Error(`Invalid orderBy: ${options.orderBy}`);
-        }
-        return sql;
-    },
-
-    processQueryOptions<T>(options: QueryOptions, pgTable: IPgTable<T>): string {
-        options = options || {};
-        let sql = '';
-
-        if (options.groupBy) {
-            sql += pgUtils.handleColumnEscapeGroupBy(options, pgTable);
-        }
-        if (options.orderBy) {
-            sql += pgUtils.handleColumnEscapeOrderBy(options, pgTable);
-
-            if (options.orderByNullsFirst != null) {
-                sql += ' NULLS ' + options.orderByNullsFirst ? 'FIRST' : 'LAST';
-            }
-        }
-        if (options.limit) {
-            if (!Number.isInteger(options.limit) || options.limit < 0) throw new Error(`Invalid limit: ${options.limit}`);
-            sql += ` LIMIT ${options.limit}`;
-        }
-        if (options.offset) {
-            if (!Number.isInteger(options.offset) || options.offset < 0) throw new Error(`Invalid offset: ${options.offset}`);
-            sql += ` OFFSET ${options.offset}`;
-        }
-        if (options.forUpdate) {
-            sql += ' FOR UPDATE';
-        }
-        return sql;
-    },
-
-    /**
-     * NOTE-DATE: there are 2 approaches to keep tz (the time correctly):
-     *    1) use Date.toISOString() function, but then the $x placeholder should be TIMESTAMP WITH TIME ZONE $x
-     *    2) use Date, and then no need to change the placeholder $x
-     *    lets use 2)
-     */
-    transformInsertUpdateParams(param: any, fieldType: FieldType) {
-        return (param != null && fieldType == FieldType.JSON) ? JSON.stringify(param) :
-            (param != null && fieldType == FieldType.TIME && !(param instanceof Date)) ? new Date(param) : param;
-    },
-
-    postProcessResult(res: any[], fields: ResultFieldType[], pgdbTypeParsers: { [oid: number]: (s: string) => any }) {
-        if (res) {
-            if (res[0] && !Array.isArray(res[0])) {
-                if (Object.keys(res[0]).length != fields.length) {
-                    throw new Error("Name collision for the query, two or more fields have the same name.");
-                }
-            }
-            pgUtils.convertTypes(res, fields, pgdbTypeParsers);
-        }
-    },
-
-    convertTypes(res: any[], fields: ResultFieldType[], pgdbTypeParsers: { [oid: number]: (s: string) => any }) {
-        let isArrayMode = Array.isArray(res[0]);
-        fields.forEach((field, i) => {
-            if (pgdbTypeParsers[field.dataTypeID]) {
-                if (isArrayMode) {
-                    res.forEach(e => e[i] = e[i] == null ? null : pgdbTypeParsers[field.dataTypeID](e[i]));
-                } else {
-                    res.forEach(e => e[field.name] = e[field.name] == null ? null : pgdbTypeParsers[field.dataTypeID](e[field.name]));
-                }
-            }
-        });
-    },
-
-    createFunctionCaller(q: IQueryAble, fn: { schema: string, name: string, return_single_row: boolean, return_single_value: boolean }) {
-        return async (...args: any[]) => {
-            let placeHolders: string[] = [];
-            let params: any[] = [];
-            args.forEach((arg) => {
-                placeHolders.push('$' + (placeHolders.length + 1));
-                params.push(arg);
-            });
-            let res = await q.query(`SELECT "${fn.schema}"."${fn.name}"(${placeHolders.join(',')})`, params);
-
-            if (fn.return_single_value) {
-                let keys = res[0] ? Object.keys(res[0]) : [];
-                if (keys.length != 1) {
-                    throw new Error(`Return type error. schema: ${fn.schema} fn: ${fn.name} expected return type: single value, current value:` + JSON.stringify(res))
-                }
-                res = res.map((r) => r[keys[0]]);
-            }
-            if (fn.return_single_row) {
-                if (res.length != 1) {
-                    throw new Error(`Return type error. schema: ${fn.schema} fn: ${fn.name} expected return type: single value, current value:` + JSON.stringify(res))
-                }
-                return res[0];
-            } else {
-                return res;
-            }
-        }
-    },
-    escapeForLike(s: string): string {
-        return s.replace(/([\\%_])/g, '\\$1');
-    }
-};

package/src/queryAble.ts

@@ -1,365 +0,0 @@
-import { PgDbLogger } from "./pgDbLogger";
-import { pgUtils } from "./pgUtils";
-import * as stream from "stream";
-import { IPgSchema } from "./pgSchemaInterface";
-import * as pg from 'pg';
-import util = require('util');
-import QueryStream = require('pg-query-stream');
-import through = require('through');
-import {ResultFieldType, IPgDb} from "./pgDbInterface";
-import {SqlQueryOptions, IQueryAble, PgRowResult } from "./queryAbleInterface"
-
-
-let defaultLogger = {
-    log: () => { },
-    error: () => { }
-};
-
-export abstract class QueryAble implements IQueryAble {
-    db!: IPgDb & IQueryAble;  // assigned in async init
-    schema!: IPgSchema;
-    /*protected*/ logger!: PgDbLogger;
-
-    public static connectionErrorListener = () => { }
-
-    setLogger(logger: PgDbLogger) {
-        this.logger = logger;
-    }
-
-    getLogger(useConsoleAsDefault = false) {
-        return this.logger || this.schema && this.schema.logger || this.db.logger || (useConsoleAsDefault ? console : defaultLogger);
-    }
-
-    /** alias to {@link query} */
-    async run(sql: string, params?: any[] | {}, options?: SqlQueryOptions): Promise<any[]> {
-        return this.query(sql, params, options);
-    }
-
-    /**
-     * Params can be
-     * 1) array, then sql should have $1 $2 for placeholders
-     * 2) object, then sql should have:
-     *    :example -> for params in statements (set/where), will be transformed to $1 $2 ...
-     *    :!example -> for DDL names (schema, table, column), will be replaced in the query
-     * e.g. query('select * from a.b where id=$1;',['the_stage_is_set']);
-     * e.g. query('select * from :!schema.:!table where id=:id;',{schema:'a',table:'b', id:'the_stage_is_set'});
-     */
-    async query(sql: string, params?: any[] | {} | null, options?: SqlQueryOptions): Promise<any[]> {
-        let connection = this.db.connection;
-        let logger = (options && options.logger || this.getLogger(false));
-        return this.internalQuery({ connection, sql, params, logger });
-    }
-
-    protected async internalQuery(options: { connection: pg.PoolClient | null, sql: string, params?: any, logger?: PgDbLogger }): Promise<any[]>;
-    protected async internalQuery(options: { connection: pg.PoolClient | null, sql: string, params?: any, logger?: PgDbLogger, rowMode: true }): Promise<PgRowResult>;
-    protected async internalQuery(options: { connection: pg.PoolClient | null, sql: string, params?: any, logger?: PgDbLogger, rowMode?: boolean }): Promise<any[] | PgRowResult> {
-        if (this.db.needToFixConnectionForListen()) {
-            await this.db.runRestartConnectionForListen();
-        }
-        let { connection, sql, params, logger } = options;
-        logger = logger || this.getLogger(false);
-
-        try {
-            if (params && !Array.isArray(params)) {
-                let p = pgUtils.processNamedParams(sql, params);
-                sql = p.sql;
-                params = p.params;
-            }
-            let query = options?.rowMode ? { text: sql, values: params, rowMode: 'array' } : { text: sql, values: params };
-            let res;
-            if (connection) {
-                logger.log('reused connection', sql, util.inspect(params, false, null), connection.processID);
-                res = await connection.query(query);
-                await this.checkAndFixOids(connection, res.fields);
-            } else {
-                connection = await this.db.pool.connect();
-                logger.log('new connection', sql, util.inspect(params, false, null), connection.processID);
-
-                connection.on('error', QueryAble.connectionErrorListener);
-                res = await connection.query(query);
-                await this.checkAndFixOids(connection, res.fields);
-
-                connection.off('error', QueryAble.connectionErrorListener);
-                connection.release();
-                connection = null;
-            }
-            this.postProcessFields(res.rows, res.fields, logger);
-            return options?.rowMode ? { columns: (res.fields || []).map(f => f.name), rows: res.rows || [] } : res.rows;
-        } catch (e) {
-            pgUtils.logError(logger, { error: <Error>e, sql, params, connection });
-            if (connection) {
-                try {
-                    //If any problem has happened in a dedicated connection, (wrong sql format or non-accessible postgres server)
-                    //close the connection to be a free connection in the pool,
-                    //but keep the db.connection member non - null to crash in all of the following commands
-                    connection.release();
-                } catch (e) {
-                    logger.error('connection error', (<Error>e).message);
-                }
-            }
-            throw e;
-        }
-    }
-
-    /**
-     * Same as query but response is two array: columns and rows and rows are arrays also not objects
-     * This is useful for queries which have colliding column names
-     */
-    async queryAsRows(sql: string, params?: any[] | {}, options?: SqlQueryOptions): Promise<PgRowResult> {
-        let connection = this.db.connection;
-        let logger = (options && options.logger || this.getLogger(false));
-        return this.internalQuery({ connection, sql, params, logger, rowMode: true });
-    }
-
-    /**
-     * If the callback function return true, the connection will be closed.
-     */
-    async queryWithOnCursorCallback(sql: string, params: any[] | Record<string, any> | null, options: SqlQueryOptions | null, callback: (res: any) => any): Promise<void> {
-        if (this.db.needToFixConnectionForListen()) {
-            await this.db.runRestartConnectionForListen();
-        }
-        let connection = this.db.connection!;
-        let logger = this.getLogger(true);
-        let positionedParams: any[] | null | undefined;
-
-        try {
-            if (params && !Array.isArray(params)) {
-                let p = pgUtils.processNamedParams(sql, params);
-                sql = p.sql;
-                params = p.params;
-            } else {
-                positionedParams = params;
-            }
-
-            let queryInternal = async () => {
-                this.getLogger(false).log(sql, util.inspect(positionedParams, false, null), connection.processID);
-                let fieldsToFix: ResultFieldType[] | undefined;
-                let isFirst = true;
-
-                let query = new QueryStream(sql, positionedParams);
-                let stream = connection.query(query);
-                await new Promise((resolve, reject) => {
-                    query.handleError = reject;
-                    stream.on('data', (res: any) => {
-                        try {
-                            let fields = stream._result && stream._result.fields || stream.cursor._result && stream.cursor._result.fields;
-                            if (isFirst) {
-                                if (this.hasUnknownOids(fields)) {
-                                    fieldsToFix = fields;
-                                    stream.destroy();
-                                    return;
-                                }
-                                isFirst = false;
-                            }
-                            this.postProcessFields([res], fields, this.getLogger(false));
-
-                            if (callback(res)) {
-                                stream.destroy();
-                            }
-                        } catch (e) {
-                            reject(e);
-                        }
-                    });
-
-                    stream.on('close', resolve);
-                    stream.on('error', reject);
-                });
-                if (fieldsToFix) {
-                    await this.checkAndFixOids(connection, fieldsToFix);
-                    query = new QueryStream(sql, positionedParams);
-                    stream = connection.query(query);
-                    await new Promise((resolve, reject) => {
-                        query.handleError = reject;
-                        stream.on('data', (res: any) => {
-                            try {
-                                let fields = stream._result && stream._result.fields || stream.cursor._result && stream.cursor._result.fields;
-                                this.postProcessFields([res], fields, this.getLogger(false));
-
-                                if (callback(res)) {
-                                    stream.destroy();
-                                }
-                            } catch (e) {
-                                reject(e);
-                            }
-                        });
-
-                        stream.on('close', resolve);
-                        stream.on('error', reject);
-                    });
-                }
-            }
-
-            if (connection) {
-                await queryInternal();
-            } else {
-                connection = await this.db.pool.connect();
-                logger.log('new connection', sql, util.inspect(positionedParams, false, null), connection.processID);
-                connection.on('error', QueryAble.connectionErrorListener);
-                await queryInternal();
-
-                connection.off('error', QueryAble.connectionErrorListener);
-                connection.release();
-            }
-        } catch (e) {
-            pgUtils.logError(logger, { error: <Error>e, sql, params, connection });
-            if (connection) {
-                try {
-                    connection.release();
-                } catch (e) {
-                    logger.error('connection error', (<Error>e).message);
-                }
-            }
-            throw e;
-        }
-    }
-
-    async queryAsStream(sql: string, params?: any[] | Record<string, any> | null, options?: SqlQueryOptions | null): Promise<stream.Readable> {
-        if (this.db.needToFixConnectionForListen()) {
-            await this.db.runRestartConnectionForListen();
-        }
-        let connection = this.db.connection;
-        let logger = (options && options.logger || this.getLogger(false));
-        let pgStream: any;
-        let queriable = this;
-        let isFirst = true;
-        let convertTypeFilter = through(function (this: stream, data) {
-            try {
-                let fields = pgStream._result && pgStream._result.fields || pgStream.cursor._result && pgStream.cursor._result.fields;
-                if (isFirst) {
-                    if (queriable.hasUnknownOids(fields)) {
-                        throw new Error('[337] Query returns fields with unknown oid.');
-                    }
-                    isFirst = false;
-                }
-                queriable.postProcessFields([data], fields, queriable.db.pgdbTypeParsers);
-
-                this.emit('data', data);
-            } catch (err) {
-                this.emit('error', err);
-            }
-        });
-        convertTypeFilter.on('error', (e: Error) => {
-            if (connection) {
-                try {
-                    connection.release();
-                } catch (e) {
-                    logger.error('connection error', (<Error>e).message);
-                }
-            }
-            connection = null;
-            pgUtils.logError(logger, { error: e, sql, params, connection });
-        });
-
-        let positionedParams: any[] | undefined | null;
-
-        try {
-            if (params && !Array.isArray(params)) {
-                let p = pgUtils.processNamedParams(sql, params);
-                sql = p.sql;
-                params = p.params;
-            } else {
-                positionedParams = params;
-            }
-
-            if (connection) {
-                logger.log(sql, util.inspect(positionedParams, false, null), connection.processID);
-                let query = new QueryStream(sql, positionedParams);
-                query.handleError = (err: Error) => {
-                    convertTypeFilter.emit('error', err);
-                };
-                pgStream = connection.query(query);
-                return pgStream.pipe(convertTypeFilter);
-            } else {
-                connection = await this.db.pool.connect();
-                logger.log('new connection', sql, util.inspect(positionedParams, false, null), connection.processID);
-                connection.on('error', QueryAble.connectionErrorListener);
-
-                let query = new QueryStream(sql, positionedParams);
-                query.handleError = (err: Error, _connection: pg.PoolClient) => {
-                    convertTypeFilter.emit('error', err);
-                };
-                pgStream = connection.query(query);
-                pgStream.on('close', () => {
-                    if (connection) {
-                        connection.off('error', QueryAble.connectionErrorListener);
-                        connection.release();
-                    }
-                    connection = null;
-                });
-                pgStream.on('error', (e: Error) => {
-                    pgUtils.logError(logger, { error: e, sql, params: positionedParams, connection });
-
-                    if (connection) {
-                        connection.off('error', QueryAble.connectionErrorListener);
-                        connection.release();
-                    }
-                    connection = null;
-                });
-                return pgStream.pipe(convertTypeFilter);
-            }
-        } catch (e) {
-            pgUtils.logError(logger, { error: <Error>e, sql, params: positionedParams, connection });
-            throw e;
-        }
-    }
-
-    async queryOne(sql: string, params?: any[] | {}, options?: SqlQueryOptions): Promise<any> {
-        let res = await this.query(sql, params, options);
-        if (res.length > 1) {
-            let logger = (options && options.logger || this.getLogger(false));
-            let error = Error('More then one rows exists');
-            pgUtils.logError(logger, { error, sql, params, connection: this.db.connection });
-            throw error;
-        }
-        return res[0];
-    }
-
-    async queryFirst(sql: string, params?: any[] | {}, options?: SqlQueryOptions): Promise<any> {
-        let res = await this.query(sql, params, options);
-        return res[0];
-    }
-
-    /** @return one record's one field */
-    async queryOneField(sql: string, params?: any[] | {}, options?: SqlQueryOptions): Promise<any> {
-        let res = await this.query(sql, params, options);
-        if (!res.length) {
-            return null;
-        }
-        let fieldName = Object.keys(res[0])[0];
-        if (res.length > 1) {
-            let logger = (options && options.logger || this.getLogger(false));
-            let error = Error('More then one field exists!');
-            pgUtils.logError(logger, { error, sql, params, connection: this.db.connection });
-            throw error;
-        }
-        return res.length == 1 ? res[0][fieldName] : null;
-    }
-
-    /** @return one column for the matching records */
-    async queryOneColumn(sql: string, params?: any[] | {}, options?: SqlQueryOptions): Promise<any[]> {
-        let res = await this.query(sql, params, options);
-        if (!res.length) {
-            return [];
-        }
-        let fieldName = Object.keys(res[0])[0];
-        return res.map(r => r[fieldName]);
-    }
-
-    private postProcessFields(rows: any[], fields: ResultFieldType[], logger: PgDbLogger) {
-        pgUtils.postProcessResult(rows, fields, this.db.pgdbTypeParsers);
-        if (this.db.postProcessResult) this.db.postProcessResult(rows, fields, logger);
-    }
-
-    private async checkAndFixOids(connection: pg.PoolClient, fields: ResultFieldType[]) {
-        if (fields) {
-            let oidList = fields.map(field => field.dataTypeID);
-            return this.db.resetMissingParsers(connection, oidList);
-        }
-    }
-
-    private hasUnknownOids(fields: ResultFieldType[]): boolean {
-        let oidList = fields.map(field => field.dataTypeID);
-        let unknownOids = oidList.filter(oid => !this.db.knownOids[oid]);
-        return !!unknownOids.length;
-    }
-}