@l-v-yonsama/multi-platform-database-drivers 0.1.1 → 0.1.2

package/build/src/db/resource/ResultSetDataHolder.js

@@ -0,0 +1,722 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RdhRow = exports.CellAnnotation = exports.AnnotationType = exports.RdhKey = exports.SampleGroupByClass = exports.SampleClassPair = void 0;
+const list_it_1 = require("list-it");
+const GeneralColumnType_1 = require("./types/GeneralColumnType");
+const enum_values_1 = require("enum-values");
+const ss = require("simple-statistics");
+const shuffle_array_1 = require("shuffle-array");
+class SampleClassPair {
+    constructor() {
+        this.sample_values = [];
+    }
+}
+exports.SampleClassPair = SampleClassPair;
+class SampleGroupByClass {
+    constructor(clazz_key, sample_keys) {
+        this.pairs = [];
+        this.sample_keys = [];
+        this.is_shuffled = false;
+        this.sample_keys = sample_keys;
+        this.clazz_key = clazz_key;
+    }
+}
+exports.SampleGroupByClass = SampleGroupByClass;
+class RdhKey {
+    constructor(name, type = GeneralColumnType_1.GeneralColumnType.UNKNOWN, comment = '') {
+        this.type = GeneralColumnType_1.GeneralColumnType.UNKNOWN;
+        this.name = name;
+        this.type = type;
+        this.comment = comment;
+    }
+    toString() {
+        return `${this.name} [${enum_values_1.EnumValues.getNameFromValue(GeneralColumnType_1.GeneralColumnType, this.type)}:${GeneralColumnType_1.GeneralColumnType.parseHandsonType(this.type)}]`;
+    }
+}
+exports.RdhKey = RdhKey;
+var AnnotationType;
+(function (AnnotationType) {
+    AnnotationType[AnnotationType["Del"] = 0] = "Del";
+    AnnotationType[AnnotationType["Upd"] = 1] = "Upd";
+    AnnotationType[AnnotationType["Add"] = 2] = "Add";
+    AnnotationType[AnnotationType["Err"] = 3] = "Err";
+    AnnotationType[AnnotationType["Lnt"] = 4] = "Lnt";
+    AnnotationType[AnnotationType["Stl"] = 5] = "Stl";
+})(AnnotationType = exports.AnnotationType || (exports.AnnotationType = {}));
+class CellAnnotation {
+    constructor(type, options) {
+        this.type = type;
+        this.options = options;
+    }
+}
+exports.CellAnnotation = CellAnnotation;
+class RdhRow {
+    constructor(meta, values) {
+        this.meta = meta;
+        this.values = values;
+    }
+    pushAnnotation(key, type, options) {
+        if (this.meta[key] === undefined) {
+            this.meta[key] = new Array();
+        }
+        this.meta[key].push(new CellAnnotation(type, options));
+    }
+    clearAnnotations(type) {
+        if (this.meta) {
+            const meta_keys = Object.keys(this.meta);
+            if (meta_keys && meta_keys.length > 0) {
+                for (let i = 0; i < meta_keys.length; i++) {
+                    const annotations = this.meta[meta_keys[i]];
+                    if (annotations) {
+                        for (let j = 0; j < annotations.length; j++) {
+                            if (annotations[j].type === type) {
+                                annotations.splice(j, 1);
+                                j--;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    getAnnotations(type) {
+        const r = new Array();
+        if (this.meta) {
+            const meta_keys = Object.keys(this.meta);
+            if (meta_keys && meta_keys.length > 0) {
+                for (let i = 0; i < meta_keys.length; i++) {
+                    const annotations = this.meta[meta_keys[i]];
+                    if (annotations) {
+                        annotations
+                            .filter((a) => a.type === type)
+                            .forEach((a) => r.push(a));
+                    }
+                }
+            }
+        }
+        return r;
+    }
+    getFirstAnnotationsOf(key, type) {
+        if (this.meta && this.meta[key]) {
+            const annotations = this.meta[key];
+            if (annotations) {
+                return annotations.find((a) => a.type === type);
+            }
+        }
+        return undefined;
+    }
+    getAnnotationsOf(key, type) {
+        const r = new Array();
+        if (this.meta && this.meta[key]) {
+            const annotations = this.meta[key];
+            if (annotations) {
+                annotations.filter((a) => a.type === type).forEach((a) => r.push(a));
+            }
+        }
+        return r;
+    }
+    hasAnnotation(type) {
+        if (this.meta) {
+            const meta_keys = Object.keys(this.meta);
+            if (meta_keys && meta_keys.length > 0) {
+                for (let i = 0; i < meta_keys.length; i++) {
+                    const annotations = this.meta[meta_keys[i]];
+                    if (annotations) {
+                        if (annotations.some((annotation) => annotation.type === type)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}
+exports.RdhRow = RdhRow;
+class ResultSetDataHolder {
+    static create(err) {
+        const rdh = new ResultSetDataHolder([]);
+        if (err) {
+            rdh.errorMessage = err.message;
+        }
+        return rdh;
+    }
+    constructor(keys, dbRes) {
+        this.is_empty = false;
+        this.keys = [];
+        this.rows = [];
+        this.setKeys(keys);
+        this.dbRes = dbRes;
+    }
+    static createEmpty() {
+        const rdh = new ResultSetDataHolder(['message']);
+        rdh.is_empty = true;
+        rdh.addRow({ message: 'empty result set' });
+        return rdh;
+    }
+    static from(list, i_titles) {
+        if (list === undefined || list === null || list === '') {
+            throw new Error(typeof list + ' has no value.');
+        }
+        const constructor = list.constructor.name;
+        if (constructor === 'ResultSetDataHolder') {
+            return list;
+        }
+        const t = typeof list;
+        let ret = ResultSetDataHolder.createEmpty();
+        // console.log('outputToSpread, list=', list, t, list.constructor.name)
+        const str_titles = new Array();
+        if (i_titles) {
+            console.log('has i_titles', i_titles);
+            if (typeof i_titles === 'string') {
+                str_titles.push(i_titles);
+            }
+            if (i_titles instanceof Array) {
+                i_titles.forEach((s) => {
+                    str_titles.push(s);
+                });
+            }
+        }
+        if (list instanceof Array) {
+            if (list.length > 0) {
+                let elm = list[0];
+                if (elm instanceof Array) {
+                    // number[][]
+                    let i = str_titles.length + 1;
+                    while (str_titles.length < elm.length) {
+                        str_titles.push(`K${i++}`);
+                    }
+                    ret = new ResultSetDataHolder(str_titles);
+                    for (let r = 0; r < list.length; r++) {
+                        elm = list[r];
+                        const values = {};
+                        for (let c = 0; c < elm.length; c++) {
+                            values[str_titles[c]] = elm[c];
+                        }
+                        ret.addRow(values);
+                    }
+                }
+            }
+        }
+        else {
+            // console.log('list.keys=', list.keys);
+            // console.log('list.rows=', list.rows);
+            // console.log('list.is_empty=', list.is_empty);
+            if (list.keys && list.rows && list.is_empty !== undefined) {
+                // rdh
+                const keyList = new Array();
+                list.keys.forEach((k) => {
+                    const new_key = new RdhKey(k.name, k.type, k.comment);
+                    new_key.width = k.width;
+                    keyList.push(new_key);
+                });
+                const rdh = new ResultSetDataHolder(keyList);
+                rdh.is_empty = list.is_empty;
+                list.rows.forEach((r) => {
+                    rdh.rows.push(new RdhRow(r.meta, r.values));
+                });
+                rdh.dbRes = list.dbRes;
+                rdh.sqlStatement = list.sqlStatement;
+                rdh.mergeCells = list.mergeCells;
+                rdh.errorMessage = list.errorMessage;
+                return rdh;
+            }
+            switch (t) {
+                case 'object':
+                    if (str_titles.length !== 2) {
+                        str_titles.splice(0, str_titles.length);
+                        str_titles.push('KEY');
+                        str_titles.push('VALUE');
+                    }
+                    ret = new ResultSetDataHolder(str_titles);
+                    Object.keys(list).forEach((k) => {
+                        const v = list[k];
+                        const values = {};
+                        values[str_titles[0]] = k;
+                        values[str_titles[1]] = v;
+                        ret.addRow(values);
+                    });
+                    break;
+            }
+        }
+        ret.resetKeyTypeByRows();
+        return ret;
+    }
+    /**
+     * The correlation is a measure of how correlated two datasets are, between -1 and 1
+     * @param key_x first input
+     * @param key_y first input
+     * @returns sample correlation
+     */
+    sampleCorrelation(key_x, key_y) {
+        const x = this.toVector(key_x, true);
+        const y = this.toVector(key_y, true);
+        return ss.sampleCorrelation(x, y);
+    }
+    describe() {
+        // #               a         b
+        // # count  4.000000  4.000000
+        // # mean   1.750000  0.600000
+        // # std    0.957427  0.439697
+        // # min    1.000000  0.100000
+        // # 25%    1.000000  0.325000
+        // # 50%    1.500000  0.600000
+        // # 75%    2.250000  0.875000
+        // # max    3.000000  1.100000
+        const desc_keys = new Array();
+        this.keys
+            .filter((k) => GeneralColumnType_1.GeneralColumnType.isNumericLike(k.type))
+            .forEach((k) => {
+            desc_keys.push(new RdhKey(k.name, k.type, k.comment));
+        });
+        desc_keys.unshift(new RdhKey('stat', GeneralColumnType_1.GeneralColumnType.TEXT));
+        const ret = new ResultSetDataHolder(desc_keys);
+        const count_values = { stat: 'count' };
+        const mean_values = { stat: 'mean' };
+        const std_values = { stat: 'std' };
+        const min_values = { stat: 'min' };
+        const quatile25_values = { stat: '25%' };
+        const median_values = { stat: '50%' };
+        const quatile75_values = { stat: '75%' };
+        const max_values = { stat: 'max' };
+        this.keys.forEach((key) => {
+            const num_list = this.toVector(key.name, true);
+            count_values[key.name] = num_list.length;
+            mean_values[key.name] = num_list.length === 0 ? '-' : ss.mean(num_list);
+            std_values[key.name] =
+                num_list.length === 0 ? '-' : ss.standardDeviation(num_list);
+            min_values[key.name] = num_list.length === 0 ? '-' : ss.min(num_list);
+            quatile25_values[key.name] =
+                num_list.length === 0 ? '-' : ss.quantile(num_list, 0.25);
+            median_values[key.name] =
+                num_list.length === 0 ? '-' : ss.median(num_list);
+            quatile75_values[key.name] =
+                num_list.length === 0 ? '-' : ss.quantile(num_list, 0.75);
+            max_values[key.name] = num_list.length === 0 ? '-' : ss.max(num_list);
+        });
+        ret.addRow(count_values);
+        ret.addRow(mean_values);
+        ret.addRow(std_values);
+        ret.addRow(min_values);
+        ret.addRow(quatile25_values);
+        ret.addRow(median_values);
+        ret.addRow(quatile75_values);
+        ret.addRow(max_values);
+        return ret;
+    }
+    splitRows(test_percentage, with_shuffle = false) {
+        // Split the data into training and testing portions.
+        if (test_percentage >= 100) {
+            test_percentage = 100;
+        }
+        if (test_percentage < 0) {
+            test_percentage = 0;
+        }
+        const numTestExamples = Math.round((this.rows.length * test_percentage) / 100);
+        const numTrainExamples = this.rows.length - numTestExamples;
+        const train = new ResultSetDataHolder(this.keys);
+        const test = new ResultSetDataHolder(this.keys);
+        const cloned_rows = this.rows.slice();
+        if (with_shuffle) {
+            (0, shuffle_array_1.default)(cloned_rows);
+        }
+        train.rows = cloned_rows.slice(0, numTrainExamples);
+        test.rows = cloned_rows.slice(numTrainExamples);
+        return [train, test];
+    }
+    /**
+     * Sample a data from each class of this resutlsets.
+     *
+     * @param {number} numExamplesPerClass Number of examples per class.
+     */
+    sampleXKeysGroupByClass(numExamplesPerClass, xKeys, clazz, shuffle = false) {
+        const ret = new SampleGroupByClass(clazz, xKeys);
+        const localIndexes = new Array();
+        for (let i = 0; i < this.rows.length; i++) {
+            localIndexes.push(i);
+        }
+        if (shuffle) {
+            ret.is_shuffled = true;
+            (0, shuffle_array_1.default)(localIndexes);
+        }
+        const uniqClassValueSets = new Set();
+        for (let j = 0; j < this.rows.length; j++) {
+            const row = this.rows[localIndexes[j]];
+            const clazz_value = row.values[clazz];
+            uniqClassValueSets.add(clazz_value);
+        }
+        const uniqClassValues = Array.from(uniqClassValueSets).sort();
+        uniqClassValues.forEach((uniq) => {
+            const pair = new SampleClassPair();
+            pair.clazz_value = uniq;
+            ret.pairs.push(pair);
+        });
+        for (let j = 0; j < this.rows.length; j++) {
+            const row = this.rows[localIndexes[j]];
+            const innerX = new Array();
+            xKeys.forEach((k) => {
+                innerX.push(row.values[k]);
+            });
+            const clazz_value = row.values[clazz];
+            const pair = ret.pairs.find((pair) => pair.clazz_value === clazz_value);
+            if (pair && pair.sample_values.length < numExamplesPerClass) {
+                pair.sample_values.push(innerX);
+            }
+            let num_full_clazz = 0;
+            ret.pairs.forEach((pair) => {
+                if (pair.sample_values.length >= numExamplesPerClass) {
+                    num_full_clazz++;
+                }
+            });
+            if (num_full_clazz >= uniqClassValues.length) {
+                break;
+            }
+        }
+        return ret;
+    }
+    nextXYBatch(batch_size, xKeys, yKey) {
+        if (this.shuffledNextCounter === undefined) {
+            this.shuffledNextCounter = 0;
+            this.shuffledIndexes = new Array();
+            for (let i = 0; i < this.rows.length; i++) {
+                this.shuffledIndexes.push(i);
+            }
+            (0, shuffle_array_1.default)(this.shuffledIndexes);
+        }
+        const x = new Array();
+        const y = new Array();
+        for (let j = 0; j < batch_size; j++) {
+            const row = this.rows[this.shuffledIndexes[this.shuffledNextCounter]];
+            const innerX = new Array();
+            xKeys.forEach((k) => {
+                innerX.push(row.values[k]);
+            });
+            x.push(innerX);
+            y.push(row.values[yKey]);
+            this.shuffledNextCounter++;
+            if (this.rows.length <= this.shuffledNextCounter) {
+                (0, shuffle_array_1.default)(this.shuffledIndexes);
+                this.shuffledNextCounter = 0;
+            }
+        }
+        return [x, y];
+    }
+    hasKey(key) {
+        return this.keys.some((k) => k.name === key);
+    }
+    drop(key) {
+        if (this.hasKey(key)) {
+            this.rows.forEach((v) => {
+                delete v.values[key];
+            });
+            const idx = this.keys.findIndex((k) => k.name === key);
+            this.keys.splice(idx, 1);
+        }
+    }
+    assign(key, list) {
+        if (list === undefined || list === null || list === '') {
+            throw new Error(typeof list + ' has no value.');
+        }
+        const constructor = list.constructor.name;
+        this.drop(key);
+        if (constructor === 'Float32Array' || constructor === 'Float64Array') {
+            list = Array.from(list);
+            this.keys.push(new RdhKey(key, GeneralColumnType_1.GeneralColumnType.NUMERIC));
+        }
+        else if (constructor === 'Int8Array' ||
+            constructor === 'Int16Array' ||
+            constructor === 'Int32Array') {
+            list = Array.from(list);
+            this.keys.push(new RdhKey(key, GeneralColumnType_1.GeneralColumnType.INTEGER));
+        }
+        else {
+            const types = new Set();
+            list.forEach((v) => {
+                if (v !== '' && v !== null) {
+                    types.add(typeof v);
+                }
+            });
+            if (types.size === 1 && types.has('number')) {
+                this.keys.push(new RdhKey(key, GeneralColumnType_1.GeneralColumnType.NUMERIC));
+            }
+            else {
+                this.keys.push(new RdhKey(key, GeneralColumnType_1.GeneralColumnType.UNKNOWN));
+            }
+        }
+        list.forEach((v, i) => {
+            this.rows[i].values[key] = v;
+        });
+    }
+    assignFromDictionary(new_key, existing_key, dictionary) {
+        this.drop(new_key);
+        this.keys.push(new RdhKey(new_key, GeneralColumnType_1.GeneralColumnType.TEXT));
+        this.rows.forEach((row) => {
+            const existing_val = row.values[existing_key];
+            if (existing_val === undefined ||
+                existing_val === '' ||
+                existing_val === null) {
+                row.values[new_key] = '';
+            }
+            else {
+                if (dictionary.length <= existing_val || existing_val < 0) {
+                    row.values[new_key] = '';
+                }
+                else {
+                    row.values[new_key] = dictionary[existing_val];
+                }
+            }
+        });
+    }
+    toVector(key_name, is_only_number = false) {
+        const retList = new Array();
+        this.rows.forEach((row) => {
+            const v = row.values[key_name];
+            if (is_only_number) {
+                if (isFinite(v) && v !== '' && v !== null) {
+                    retList.push(v);
+                }
+            }
+            else {
+                retList.push(v);
+            }
+        });
+        return retList;
+    }
+    toMatrixArray(key_names) {
+        const retList = new Array();
+        this.rows.forEach((row) => {
+            const retRow = new Array();
+            if (key_names && key_names.length > 0) {
+                key_names.forEach((key_name) => {
+                    retRow.push(row.values[key_name]);
+                });
+            }
+            else {
+                this.keys.forEach((key) => {
+                    retRow.push(row.values[key.name]);
+                });
+            }
+            retList.push(retRow);
+        });
+        return retList;
+    }
+    toCsv(config) {
+        if (config === undefined) {
+            config = {};
+        }
+        const retList = new Array();
+        if (config.key_names && config.key_names.length > 0) {
+            retList.push(config.key_names.join(','));
+        }
+        else {
+            retList.push(this.keys.map((k) => k.name).join(','));
+        }
+        this.rows.forEach((row) => {
+            const retRow = new Array();
+            if (config.key_names && config.key_names.length > 0) {
+                config.key_names.forEach((key_name) => {
+                    retRow.push(row.values[key_name]);
+                });
+            }
+            else {
+                this.keys.forEach((key) => {
+                    retRow.push(row.values[key.name]);
+                });
+            }
+            retList.push(retRow.join(','));
+        });
+        return retList.join('\r\n');
+    }
+    addRow(recordData, default_meta) {
+        let meta = {};
+        if (default_meta) {
+            meta = default_meta;
+        }
+        const values = {};
+        this.keys.forEach((key) => {
+            values[key.name] = recordData[key.name];
+        });
+        this.rows.push(new RdhRow(meta, values));
+    }
+    clearRows() {
+        this.rows.splice(0, this.rows.length);
+    }
+    copyFrom(that) {
+        this.clearRows();
+        this.keys.splice(0, this.keys.length);
+        this.setKeys(that.keys);
+        that.rows.forEach((v) => {
+            this.addRow(v);
+        });
+    }
+    setSqlStatement(sqlStatement) {
+        this.sqlStatement = sqlStatement;
+    }
+    setDbRes(dbRes) {
+        this.dbRes = dbRes;
+    }
+    hasAnnotation(type) {
+        let r = false;
+        for (let i = 0; i < this.rows.length; i++) {
+            if (this.rows[i].hasAnnotation(type)) {
+                r = true;
+                break;
+            }
+        }
+        return r;
+    }
+    fillnull(how) {
+        this.keys
+            .filter((k) => GeneralColumnType_1.GeneralColumnType.isNumericLike(k.type))
+            .forEach((k) => {
+            const num_list = new Array();
+            for (let i = 0; i < this.rows.length; i++) {
+                const v = this.rows[i].values[k.name];
+                if (isFinite(v) && v !== '') {
+                    num_list.push(v);
+                }
+            }
+            let new_value = 0;
+            switch (how) {
+                case 'mean':
+                    new_value = ss.mean(num_list);
+                    break;
+                case 'median':
+                    new_value = ss.median(num_list);
+                    break;
+            }
+            for (let i = 0; i < this.rows.length; i++) {
+                if (this.rows[i].values[k.name] === null) {
+                    this.rows[i].values[k.name] = new_value;
+                }
+            }
+        });
+    }
+    resetKeyTypeByRows() {
+        this.keys.forEach((k) => {
+            const length = this.rows.length;
+            const types = new Set();
+            for (let i = 0; i < length; i++) {
+                const v = this.rows[i].values[k.name];
+                if (v === '' || v === null) {
+                    continue;
+                }
+                types.add(typeof v);
+            }
+            if (types.size === 1 && types.has('number')) {
+                k.type = GeneralColumnType_1.GeneralColumnType.NUMERIC;
+                for (let i = 0; i < length; i++) {
+                    if (this.rows[i].values[k.name] === '') {
+                        this.rows[i].values[k.name] = null;
+                    }
+                }
+            }
+        });
+    }
+    setKeys(keys) {
+        keys.forEach((k) => {
+            if (k instanceof RdhKey) {
+                this.keys.push(k);
+            }
+            else {
+                this.keys.push(new RdhKey(k));
+            }
+        });
+    }
+    keynames(is_only_numeric_like = false) {
+        if (is_only_numeric_like) {
+            return this.keys
+                .filter((k) => GeneralColumnType_1.GeneralColumnType.isNumericLike(k.type))
+                .map((k) => k.name);
+        }
+        return this.keys.map((k) => k.name);
+    }
+    // FieldPacket {
+    //   catalog: 'def',
+    //   db: 'com',
+    //   table: 'nten',
+    //   orgTable: 'nten',
+    //   name: 'ration_tim',
+    //   orgName: 'ration_tim',
+    //   charsetNr: 63,
+    //   length: 11,
+    //   type: 3,
+    //   flags: 0,
+    //   decimals: 0,
+    //   default: undefined,
+    //   zeroFill: false,
+    //   protocol41: true }
+    addKey(k) {
+        if (this.keys === undefined) {
+            this.keys = [];
+        }
+        if (k instanceof RdhKey) {
+            this.keys.push(k);
+        }
+        else {
+            this.keys.push(new RdhKey(k));
+        }
+    }
+    toShortString(o) {
+        const s = '' + o;
+        if (s.length > 48) {
+            return s.substring(0, 48) + '..';
+        }
+        else {
+            return s;
+        }
+    }
+    toString(num_of_print = 8) {
+        if (this.keys.length < 0) {
+            if (this.errorMessage) {
+                return 'No Keys. Error:' + this.errorMessage;
+            }
+            else {
+                return 'No Keys. There is nothing error.';
+            }
+        }
+        const buf = list_it_1.default.buffer();
+        buf.d('ROW');
+        this.keys.forEach((k) => {
+            buf.d(this.toShortString(k.name));
+        });
+        buf.nl();
+        buf.d(enum_values_1.EnumValues.getNameFromValue(GeneralColumnType_1.GeneralColumnType, GeneralColumnType_1.GeneralColumnType.INTEGER));
+        this.keys.forEach((k) => {
+            buf.d(enum_values_1.EnumValues.getNameFromValue(GeneralColumnType_1.GeneralColumnType, k.type));
+        });
+        buf.nl();
+        if (this.rows.length <= num_of_print) {
+            this.rows.forEach((v, idx) => {
+                buf.d(idx + 1);
+                this.keys.forEach((k) => {
+                    buf.d(this.toShortString(v.values[k.name]));
+                });
+                buf.nl();
+            });
+        }
+        else {
+            const num_of_head = Math.ceil(num_of_print / 2);
+            this.rows.slice(0, num_of_head).forEach((v, idx) => {
+                buf.d(idx + 1);
+                this.keys.forEach((k) => {
+                    buf.d(this.toShortString(v.values[k.name]));
+                });
+                buf.nl();
+            });
+            this.rows
+                .slice(this.rows.length - num_of_head, this.rows.length)
+                .forEach((v, idx) => {
+                buf.d(this.rows.length - num_of_head + idx + 1);
+                this.keys.forEach((k) => {
+                    buf.d(this.toShortString(v.values[k.name]));
+                });
+                buf.nl();
+            });
+        }
+        return (`RDH NumOfRows:${this.rows.length} Error:${this.errorMessage}\n` +
+            buf.toString());
+    }
+}
+exports.default = ResultSetDataHolder;
+//# sourceMappingURL=ResultSetDataHolder.js.map