access-db/lib/utils/utils.js

[统一数据库的连接]Unified access to all kinds of databases

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.fastdbSort = exports.RedisSortStr = exports.RedisSortNum = exports.stringTimeNumSort = exports.changeSqlParam = exports.changeFindGeoJson = exports.changeSetManyParams = exports.changeSetParams = exports.cloneDeep = exports.isNumber = exports.isArray = exports.isJson = exports.isMongodbObjectId = void 0;
const error_1 = require("../constants/error");
const isMongodbObjectId = (value) => {
    if (!value)
        throw new Error(error_1.ID_EMPTY_ERROR);
    return value._bsontype === 'ObjectID';
};
exports.isMongodbObjectId = isMongodbObjectId;
const isJson = (value) => {
    return typeof (value) === 'object';
};
exports.isJson = isJson;
//isArray属于isJson
const isArray = (value) => {
    return Object.prototype.toString.call(value) === '[object Array]';
};
exports.isArray = isArray;
const isNumber = (value) => {
    return typeof (value) === 'number' && !isNaN(value);
};
exports.isNumber = isNumber;
// 检查polygon是否对
const isPolygonArr = (arr) => {
    if ((arr.length < 4) || (arr[0][0] !== arr[arr.length - 1][0]) || (arr[0][1] !== arr[arr.length - 1][1])) {
        throw new Error(error_1.GEO_POLYGON_ERROR);
    }
    else {
        return true;
    }
};
// 目前仅支持对象或数字的拷贝
const cloneDeep = (source) => {
    if (source === undefined || source === null)
        return Object.create(null);
    const target = (0, exports.isArray)(source) ? [] : Object.create(Object.getPrototypeOf(source));
    for (const keys in source) {
        if (source.hasOwnProperty(keys)) {
            if (source[keys] && typeof source[keys] === 'object') {
                target[keys] = (0, exports.isArray)(source[keys]) ? [] : {};
                target[keys] = (0, exports.cloneDeep)(source[keys]);
            }
            else {
                target[keys] = source[keys];
            }
        }
    }
    return target;
};
exports.cloneDeep = cloneDeep;
// 返回新增的对象，geopoint化
const changeSetParams = (params) => {
    let changeData = params;
    for (let p in params) {
        if ((0, exports.isArray)(params[p])) {
            if (params[p][0] === 'geo') {
                if ((0, exports.isArray)(params[p][1])) {
                    let temp = params[p];
                    temp.shift();
                    if (temp.length > 1) {
                        isPolygonArr(temp);
                        changeData[p] = (0, exports.cloneDeep)({
                            type: 'Polygon',
                            coordinates: [temp]
                        });
                    }
                    else {
                        changeData[p] = (0, exports.cloneDeep)({
                            type: 'Point',
                            coordinates: temp[0]
                        });
                    }
                }
            }
        }
    }
    return changeData;
};
exports.changeSetParams = changeSetParams;
const changeSetManyParams = (params) => {
    let change = [];
    for (let i = 0; i < params.length; i++) {
        change.push((0, exports.changeSetParams)(params[i]));
    }
    return change;
};
exports.changeSetManyParams = changeSetManyParams;
// 返回geojson
const changeFindGeoJson = (lparams) => {
    let temp = [];
    if (lparams[1] === 'within') {
        lparams.splice(0, 2);
        isPolygonArr(lparams);
        temp = (0, exports.cloneDeep)({
            type: 'Polygon',
            coordinates: [lparams]
        });
    }
    else {
        temp = (0, exports.cloneDeep)({
            type: 'Point',
            coordinates: lparams[2]
        });
    }
    return temp;
};
exports.changeFindGeoJson = changeFindGeoJson;
// 返回mysql语句的参数类型
const changeSqlParam = (param) => {
    let result = `'${param}'`;
    if (param) {
        // param 存在
        if ((0, exports.isNumber)(param)) {
            result = param;
        }
        if (typeof (param) === 'string') {
            result = `'${param.replace("'", "\\\'")}'`;
        }
        if (typeof (param) === 'boolean') {
            result = 'TRUE';
        }
    }
    else {
        // param 为否  可能为   null '' 0 false
        if (typeof (param) === 'undefined') {
            result = `''`;
        }
        if (typeof (param) === 'string') {
            result = `''`;
        }
        if (typeof (param) === 'number' && !isNaN(param)) {
            result = 0;
        }
        if (typeof (param) === 'boolean') {
            result = 'FALSE';
        }
        if (typeof (param) === 'object') {
            result = 'NULL';
        }
    }
    return result;
};
exports.changeSqlParam = changeSqlParam;
// 快速排序，推荐，用于redis默认排序,默认的存入的时间先后
const stringTimeNumSort = (arr, list) => {
    function main(arr, left, right, list) {
        if (arr.length === 1) {
            return;
        }
        let index = partition(arr, left, right, list);
        if (left < index - 1) {
            main(arr, left, index - 1, list);
        }
        if (index < right) {
            main(arr, index, right, list);
        }
    }
    function partition(arr, left, right, list) {
        let pivot = arr[Math.floor((left + right) / 2)];
        while (left <= right) {
            while (arr[left] > pivot) {
                left++;
            }
            while (arr[right] < pivot) {
                right--;
            }
            if (left <= right) {
                let temp = arr[right];
                arr[right] = arr[left];
                arr[left] = temp;
                temp = list[right];
                list[right] = list[left];
                list[left] = temp;
                left++;
                right--;
            }
        }
        return left;
    }
    let left = 0, right = arr.length - 1;
    main(arr, left, right, list);
    return list;
};
exports.stringTimeNumSort = stringTimeNumSort;
// 按数组对象的值,数字，降序排列，用于redis
const RedisSortNum = (arr, key, isUp = 1) => {
    if (isUp === 1) {
        function main(arr, left, right) {
            if (arr.length === 1) {
                return;
            }
            let index = partition(arr, left, right);
            if (left < index - 1) {
                main(arr, left, index - 1);
            }
            if (index < right) {
                main(arr, index, right);
            }
        }
        function partition(arr, left, right) {
            let pivot = +(arr[Math.floor((left + right) / 2)][key] || 0);
            while (left <= right) {
                while (+(arr[left][key] || 0) < pivot) {
                    left++;
                }
                while (+(arr[right][key] || 0) > pivot) {
                    right--;
                }
                if (left <= right) {
                    let temp = arr[right];
                    arr[right] = arr[left];
                    arr[left] = temp;
                    left++;
                    right--;
                }
            }
            return left;
        }
        let left = 0, right = arr.length - 1;
        main(arr, left, right);
        return arr;
    }
    else {
        function main(arr, left, right) {
            if (arr.length === 1) {
                return;
            }
            let index = partition(arr, left, right);
            if (left < index - 1) {
                main(arr, left, index - 1);
            }
            if (index < right) {
                main(arr, index, right);
            }
        }
        function partition(arr, left, right) {
            let pivot = +(arr[Math.floor((left + right) / 2)][key] || 0);
            while (left <= right) {
                while (+(arr[left][key] || 0) > pivot) {
                    left++;
                }
                while (+(arr[right][key] || 0) < pivot) {
                    right--;
                }
                if (left <= right) {
                    let temp = arr[right];
                    arr[right] = arr[left];
                    arr[left] = temp;
                    left++;
                    right--;
                }
            }
            return left;
        }
        let left = 0, right = arr.length - 1;
        main(arr, left, right);
        return arr;
    }
};
exports.RedisSortNum = RedisSortNum;
// 按数组对象的值，降序排列，用于redis
const RedisSortStr = (arr, key, isUp = 1) => {
    if (isUp === 1) {
        function main(arr, left, right) {
            if (arr.length === 1) {
                return;
            }
            let index = partition(arr, left, right);
            if (left < index - 1) {
                main(arr, left, index - 1);
            }
            if (index < right) {
                main(arr, index, right);
            }
        }
        function partition(arr, left, right) {
            let pivot = arr[Math.floor((left + right) / 2)][key];
            while (left <= right) {
                while (arr[left][key] < pivot) {
                    left++;
                }
                while (arr[right][key] > pivot) {
                    right--;
                }
                if (left <= right) {
                    let temp = arr[right];
                    arr[right] = arr[left];
                    arr[left] = temp;
                    left++;
                    right--;
                }
            }
            return left;
        }
        let left = 0, right = arr.length - 1;
        main(arr, left, right);
        return arr;
    }
    else {
        function main(arr, left, right) {
            if (arr.length === 1) {
                return;
            }
            let index = partition(arr, left, right);
            if (left < index - 1) {
                main(arr, left, index - 1);
            }
            if (index < right) {
                main(arr, index, right);
            }
        }
        function partition(arr, left, right) {
            let pivot = arr[Math.floor((left + right) / 2)][key];
            while (left <= right) {
                while (arr[left][key] > pivot) {
                    left++;
                }
                while (arr[right][key] < pivot) {
                    right--;
                }
                if (left <= right) {
                    let temp = arr[right];
                    arr[right] = arr[left];
                    arr[left] = temp;
                    left++;
                    right--;
                }
            }
            return left;
        }
        let left = 0, right = arr.length - 1;
        main(arr, left, right);
        return arr;
    }
};
exports.RedisSortStr = RedisSortStr;
// 排序 find，fastdb
const fastdbSort = (arr, key, isUp = 1) => {
    if (isUp === 1) {
        function main(arr, left, right) {
            if (arr.length === 1) {
                return;
            }
            let index = partition(arr, left, right);
            if (left < index - 1) {
                main(arr, left, index - 1);
            }
            if (index < right) {
                main(arr, index, right);
            }
        }
        function partition(arr, left, right) {
            let pivot = arr[Math.floor((left + right) / 2)][key];
            while (left <= right) {
                while (arr[left][key] < pivot) {
                    left++;
                }
                while (arr[right][key] > pivot) {
                    right--;
                }
                if (left <= right) {
                    let temp = arr[right];
                    arr[right] = arr[left];
                    arr[left] = temp;
                    left++;
                    right--;
                }
            }
            return left;
        }
        let left = 0, right = arr.length - 1;
        main(arr, left, right);
    }
    else {
        function main(arr, left, right) {
            if (arr.length === 1) {
                return;
            }
            let index = partition(arr, left, right);
            if (left < index - 1) {
                main(arr, left, index - 1);
            }
            if (index < right) {
                main(arr, index, right);
            }
        }
        function partition(arr, left, right) {
            let pivot = arr[Math.floor((left + right) / 2)][key];
            while (left <= right) {
                while (arr[left][key] > pivot) {
                    left++;
                }
                while (arr[right][key] < pivot) {
                    right--;
                }
                if (left <= right) {
                    let temp = arr[right];
                    arr[right] = arr[left];
                    arr[left] = temp;
                    left++;
                    right--;
                }
            }
            return left;
        }
        let left = 0, right = arr.length - 1;
        main(arr, left, right);
    }
    return arr;
};
exports.fastdbSort = fastdbSort;