@maiyunnet/kebab 2.0.0

package/sys/mod.js

@@ -0,0 +1,1273 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const lSql = __importStar(require("~/lib/sql"));
+const lTime = __importStar(require("~/lib/time"));
+const lCore = __importStar(require("~/lib/core"));
+const lText = __importStar(require("~/lib/text"));
+const sCtr = __importStar(require("~/sys/ctr"));
+class Rows {
+    constructor(initialItems = []) {
+        this._items = [];
+        this._items = initialItems;
+    }
+    get length() {
+        return this._items.length;
+    }
+    item(index) {
+        return this._items[index];
+    }
+    toArray() {
+        const arr = [];
+        for (const item of this._items) {
+            arr.push(item.toArray());
+        }
+        return arr;
+    }
+    filter(predicate) {
+        const items = [];
+        for (let i = 0; i < this._items.length; ++i) {
+            if (!predicate(this._items[i], i)) {
+                continue;
+            }
+            items.push(this._items[i]);
+        }
+        return new Rows(items);
+    }
+    map(allbackfn) {
+        const items = [];
+        for (let i = 0; i < this._items.length; ++i) {
+            items.push(allbackfn(this._items[i], i));
+        }
+        return items;
+    }
+    [Symbol.iterator]() {
+        let index = 0;
+        return {
+            next: () => {
+                if (index < this._items.length) {
+                    return {
+                        value: this._items[index++],
+                        done: false
+                    };
+                }
+                else {
+                    return {
+                        value: undefined,
+                        done: true
+                    };
+                }
+            }
+        };
+    }
+}
+class Mod {
+    constructor(opt) {
+        this._updates = {};
+        this._data = {};
+        this._index = null;
+        this._contain = null;
+        this._total = [];
+        this._ctr = undefined;
+        this._limit = [0, 0];
+        this._ctr = opt.ctr;
+        this._db = opt.db;
+        this._sql = lSql.get(opt.pre ?? opt.ctr);
+        if (opt.index) {
+            this._index = typeof opt.index === 'string' ? [opt.index] : [...new Set(opt.index)];
+        }
+        if (opt.contain) {
+            this._contain = opt.contain;
+        }
+        if (opt.row) {
+            for (const k in opt.row) {
+                const v = opt.row[k];
+                this._data[k] = v;
+                this[k] = v;
+            }
+        }
+        const select = opt.select ?? (opt.where ? '*' : '');
+        if (select) {
+            this._sql.select(select, this.constructor._$table +
+                (this._index !== null ? ('_' + this._index[0]) : '') +
+                (opt.alias ? ' ' + opt.alias : ''));
+        }
+        if (opt.where !== undefined) {
+            if (this.constructor._soft && !opt.raw) {
+                if (typeof opt.where === 'string') {
+                    opt.where = opt.where ? ('(' + opt.where + ') AND ') : '`time_remove` = 0';
+                }
+                else if (Array.isArray(opt.where)) {
+                    opt.where.push({
+                        'time_remove': 0
+                    });
+                }
+                else {
+                    opt.where['time_remove'] = 0;
+                }
+            }
+            this._sql.where(opt.where);
+        }
+    }
+    static column(field) {
+        return lSql.column(field);
+    }
+    static async insert(db, cs, vs, opt = {}) {
+        const sq = lSql.get(opt.pre);
+        sq.insert(this._$table + (opt.index ? ('_' + opt.index) : '')).values(cs, vs);
+        const r = await db.execute(sq.getSql(), sq.getData());
+        if (r.packet === null) {
+            await lCore.log(opt.pre instanceof sCtr.Ctr ? opt.pre : {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[insert, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1), '-error');
+            return false;
+        }
+        if (r.packet.affectedRows > 0) {
+            return true;
+        }
+        else {
+            return null;
+        }
+    }
+    static insertSql(cs, vs, opt = {}) {
+        const sq = lSql.get(opt.pre);
+        sq.insert(this._$table + (opt.index ? ('_' + opt.index) : '')).values(cs, vs);
+        return sq.format();
+    }
+    static async insertDuplicate(db, data, update, opt = {}) {
+        const sq = lSql.get(opt.pre);
+        sq.insert(this._$table + (opt.index ? ('_' + opt.index) : '')).values(data).duplicate(update);
+        const r = await db.execute(sq.getSql(), sq.getData());
+        if (r.packet === null) {
+            await lCore.log(opt.pre instanceof sCtr.Ctr ? opt.pre : {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[insertDuplicate, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (r.packet.affectedRows > 0) {
+            return true;
+        }
+        else {
+            return null;
+        }
+    }
+    static async removeByWhere(db, where, opt = {}) {
+        const tim = lTime.stamp();
+        const sq = lSql.get(opt.pre);
+        if (this._$soft && !opt.raw) {
+            sq.update(this._$table + (opt.index ? ('_' + opt.index) : ''), [{
+                    'time_remove': tim
+                }]);
+            if (typeof where === 'string') {
+                where = '(' + where + ') AND `time_remove` = 0';
+            }
+            else if (Array.isArray(where)) {
+                where.push({
+                    'time_remove': 0
+                });
+            }
+            else {
+                where['time_remove'] = 0;
+            }
+        }
+        else {
+            sq.delete(this._$table + (opt.index ? ('_' + opt.index) : ''));
+        }
+        sq.where(where);
+        if (opt.by) {
+            sq.by(opt.by[0], opt.by[1]);
+        }
+        if (opt.limit) {
+            sq.limit(opt.limit[0], opt.limit[1]);
+        }
+        const r = await db.execute(sq.getSql(), sq.getData());
+        if (r.packet === null) {
+            await lCore.log(opt.pre instanceof sCtr.Ctr ? opt.pre : {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[removeByWhere, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (r.packet.affectedRows > 0) {
+            return r.packet.affectedRows;
+        }
+        return null;
+    }
+    static removeByWhereSql(db, where, opt = {}) {
+        const tim = lTime.stamp();
+        const sq = lSql.get(opt.pre);
+        if (this._$soft && !opt.raw) {
+            sq.update(this._$table + (opt.index ? ('_' + opt.index) : ''), [{
+                    'time_remove': tim
+                }]);
+            if (typeof where === 'string') {
+                where = '(' + where + ') AND `time_remove` = 0';
+            }
+            else if (Array.isArray(where)) {
+                where.push({
+                    'time_remove': 0
+                });
+            }
+            else {
+                where['time_remove'] = 0;
+            }
+        }
+        else {
+            sq.delete(this._$table + (opt.index ? ('_' + opt.index) : ''));
+        }
+        sq.where(where);
+        if (opt.by) {
+            sq.by(opt.by[0], opt.by[1]);
+        }
+        if (opt.limit) {
+            sq.limit(opt.limit[0], opt.limit[1]);
+        }
+        return sq;
+    }
+    static async updateByWhere(db, data, where, opt = {}) {
+        if (typeof opt.index === 'string') {
+            opt.index = [opt.index];
+        }
+        else if (!opt.index) {
+            opt.index = [''];
+        }
+        if (this._$soft && !opt.raw) {
+            if (typeof where === 'string') {
+                where = '(' + where + ') AND `time_remove` = 0';
+            }
+            else if (Array.isArray(where)) {
+                where.push({
+                    'time_remove': 0
+                });
+            }
+            else {
+                where['time_remove'] = 0;
+            }
+        }
+        let ar = 0;
+        for (const index of opt.index) {
+            const sq = lSql.get(opt.pre);
+            sq.update(this._$table + (index ? ('_' + index) : ''), data);
+            sq.where(where);
+            if (opt.by) {
+                sq.by(opt.by[0], opt.by[1]);
+            }
+            if (opt.limit) {
+                sq.limit(opt.limit[0], opt.limit[1]);
+            }
+            const r = await db.execute(sq.getSql(), sq.getData());
+            if (r.packet === null) {
+                await lCore.log(opt.pre instanceof sCtr.Ctr ? opt.pre : {
+                    'path': '',
+                    'urlFull': '',
+                    'hostname': '',
+                    'req': null,
+                    'get': {},
+                    'cookie': {},
+                    'headers': {}
+                }, '[updateByWhere, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+                return false;
+            }
+            if (r.packet.affectedRows > 0) {
+                ar += r.packet.affectedRows;
+            }
+        }
+        return ar ? ar : null;
+    }
+    static updateByWhereSql(data, where, opt = {}) {
+        const sq = lSql.get(opt.pre);
+        sq.update(this._$table + (opt.index ? ('_' + opt.index) : ''), data);
+        if (this._$soft && !opt.raw) {
+            if (typeof where === 'string') {
+                where = '(' + where + ') AND `time_remove` = 0';
+            }
+            else if (Array.isArray(where)) {
+                where.push({
+                    'time_remove': 0
+                });
+            }
+            else {
+                where['time_remove'] = 0;
+            }
+        }
+        sq.where(where);
+        if (opt.by) {
+            sq.by(opt.by[0], opt.by[1]);
+        }
+        if (opt.limit) {
+            sq.limit(opt.limit[0], opt.limit[1]);
+        }
+        return sq;
+    }
+    static select(db, c, opt = {}) {
+        return new this({
+            'db': db,
+            'ctr': opt.ctr,
+            'pre': opt.pre,
+            'select': c,
+            'index': opt.index,
+            'alias': opt.alias,
+            'contain': opt.contain
+        });
+    }
+    static where(db, s = '', opt = {}) {
+        return new this({
+            'db': db,
+            'ctr': opt.ctr,
+            'pre': opt.pre,
+            'where': s,
+            'raw': opt.raw,
+            'index': opt.index,
+            'contain': opt.contain
+        });
+    }
+    static getCreate(db, opt = {}) {
+        return new this({
+            'db': db,
+            'ctr': opt.ctr,
+            'pre': opt.pre,
+            'index': opt.index
+        });
+    }
+    static find(db, val, opt = {}) {
+        return new this({
+            'db': db,
+            'ctr': opt.ctr,
+            'pre': opt.pre,
+            'where': [{
+                    [this._$primary]: val
+                }],
+            'raw': opt.raw,
+            'index': opt.index
+        }).first(opt.lock);
+    }
+    static async one(db, s, opt = {}) {
+        if (!opt.index) {
+            const o = new this({
+                'select': opt.select,
+                'db': db,
+                'ctr': opt.ctr,
+                'pre': opt.pre,
+                'where': s,
+                'raw': opt.raw
+            });
+            if (opt.by) {
+                o.by(opt.by[0], opt.by[1]);
+            }
+            return opt.array ? o.firstArray() : o.first();
+        }
+        opt.index = typeof opt.index === 'string' ? [opt.index] : [...new Set(opt.index)];
+        for (const item of opt.index) {
+            const row = new this({
+                'select': opt.select,
+                'db': db,
+                'ctr': opt.ctr,
+                'pre': opt.pre,
+                'where': s,
+                'raw': opt.raw,
+                'index': item
+            });
+            if (opt.by) {
+                row.by(opt.by[0], opt.by[1]);
+            }
+            const rowr = await (opt.array ? row.firstArray() : row.first());
+            if (rowr) {
+                return rowr;
+            }
+            if (rowr === false) {
+                return false;
+            }
+        }
+        return null;
+    }
+    static async oneArray(db, s, opt = {}) {
+        opt.array = true;
+        return this.one(db, s, opt);
+    }
+    static async primarys(db, where = '', opt = {}) {
+        const sq = lSql.get(opt.pre ?? opt.ctr);
+        if (this._$soft && !opt.raw) {
+            if (typeof where === 'string') {
+                if (where !== '') {
+                    where = '(' + where + ') AND `time_remove` = 0';
+                }
+            }
+            else if (Array.isArray(where)) {
+                where.push({
+                    'time_remove': 0
+                });
+            }
+            else {
+                where['time_remove'] = 0;
+            }
+        }
+        sq.select(this._$primary, this._$table + (opt.index ? ('_' + opt.index) : '')).where(where);
+        const r = await db.query(sq.getSql(), sq.getData());
+        if (r.rows === null) {
+            await lCore.log(opt.ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[primarys, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        const primarys = [];
+        for (const row of r.rows) {
+            primarys.push(row[this._$primary]);
+        }
+        return primarys;
+    }
+    static toArrayByRecord(obj) {
+        const rtn = {};
+        for (const key in obj) {
+            rtn[key] = obj[key].toArray();
+        }
+        return rtn;
+    }
+    set(n, v) {
+        if (typeof n === 'object') {
+            for (const k in n) {
+                const v = n[k];
+                if (v === undefined) {
+                    continue;
+                }
+                this._updates[k] = true;
+                this._data[k] = v;
+                this[k] = v;
+            }
+        }
+        else {
+            if (v === undefined) {
+                return;
+            }
+            if (typeof n !== 'string') {
+                return;
+            }
+            this._updates[n] = true;
+            this._data[n] = v;
+            this[n] = v;
+        }
+    }
+    get(n) {
+        return this._data[n];
+    }
+    async create(notWhere, table) {
+        const cstr = this.constructor;
+        const updates = {};
+        for (const k in this._updates) {
+            updates[k] = this._data[k];
+        }
+        if (!table) {
+            table = cstr._$table + (this._index ? ('_' + this._index[0]) : '');
+        }
+        let r = null;
+        if ((cstr._$key !== '') && (updates[cstr._$key] === undefined)) {
+            let count = 0;
+            while (true) {
+                if (count === 3) {
+                    return false;
+                }
+                updates[cstr._$key] = this._keyGenerator();
+                this._data[cstr._$key] = updates[cstr._$key];
+                this[cstr._$key] = updates[cstr._$key];
+                this._sql.insert(cstr._$table + (this._index ? ('_' + this._index[0]) : ''));
+                if (notWhere) {
+                    this._sql.notExists(table, updates, notWhere);
+                }
+                else {
+                    this._sql.values(updates);
+                }
+                r = await this._db.execute(this._sql.getSql(), this._sql.getData());
+                ++count;
+                if (!r.error) {
+                    break;
+                }
+                if (r.error.errno !== 1062) {
+                    await lCore.log(this._ctr ?? {
+                        'path': '',
+                        'urlFull': '',
+                        'hostname': '',
+                        'req': null,
+                        'get': {},
+                        'cookie': {},
+                        'headers': {}
+                    }, '[create0, mod] [' + table + '] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+                    return false;
+                }
+            }
+        }
+        else {
+            this._sql.insert(cstr._$table + (this._index ? ('_' + this._index[0]) : ''));
+            if (notWhere) {
+                this._sql.notExists(table, updates, notWhere);
+            }
+            else {
+                this._sql.values(updates);
+            }
+            r = await this._db.execute(this._sql.getSql(), this._sql.getData());
+            if (r.error) {
+                if (r.error.errno !== 1062) {
+                    await lCore.log(this._ctr ?? {
+                        'path': '',
+                        'urlFull': '',
+                        'hostname': '',
+                        'req': null,
+                        'get': {},
+                        'cookie': {},
+                        'headers': {}
+                    }, '[create1, mod] [' + table + '] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+                }
+                return false;
+            }
+        }
+        if (r?.packet?.affectedRows && r?.packet?.affectedRows > 0) {
+            this._updates = {};
+            this._data[cstr._$primary] = r.packet.insertId;
+            this[cstr._$primary] = this._data[cstr._$primary];
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async replace() {
+        const cstr = this.constructor;
+        const updates = {};
+        for (const k in this._updates) {
+            updates[k] = this._data[k];
+        }
+        this._sql.replace(cstr._$table + (this._index ? ('_' + this._index[0]) : '')).values(updates);
+        const r = await this._db.execute(this._sql.getSql(), this._sql.getData());
+        if (r.packet === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[replace, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (r.packet.affectedRows > 0) {
+            this._updates = {};
+            this._data[cstr._$primary] = r.packet.insertId;
+            this[cstr._$primary] = this._data[cstr._$primary];
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async refresh(lock = false) {
+        const cstr = this.constructor;
+        this._sql.select('*', cstr._$table + (this._index ? ('_' + this._index[0]) : '')).where([{
+                [cstr._$primary]: this._data[cstr._$primary]
+            }]);
+        if (lock) {
+            this._sql.lock();
+        }
+        const r = await this._db.query(this._sql.getSql(), this._sql.getData());
+        if (r.rows === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[refresh, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (r.rows.length === 0) {
+            return null;
+        }
+        for (const k in r.rows[0]) {
+            const v = r.rows[0][k];
+            this._data[k] = v;
+            this[k] = v;
+        }
+        return true;
+    }
+    async save() {
+        if (Object.keys(this._updates).length === 0) {
+            return true;
+        }
+        const cstr = this.constructor;
+        const updates = {};
+        for (const k in this._updates) {
+            updates[k] = this._data[k];
+        }
+        this._sql.update(cstr._$table + (this._index ? ('_' + this._index[0]) : ''), [updates]).where([{
+                [cstr._$primary]: this._data[cstr._$primary]
+            }]);
+        const r = await this._db.execute(this._sql.getSql(), this._sql.getData());
+        if (r.packet === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[save, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (r.packet.affectedRows > 0) {
+            this._updates = {};
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async remove(raw = false) {
+        const tim = lTime.stamp();
+        const cstr = this.constructor;
+        if (cstr._$soft && !raw) {
+            this._sql.update(cstr._$table + (this._index ? ('_' + this._index[0]) : ''), [{
+                    'time_remove': tim
+                }]).where([{
+                    [cstr._$primary]: this._data[cstr._$primary],
+                    'time_remove': 0
+                }]);
+        }
+        else {
+            this._sql.delete(cstr._$table + (this._index ? ('_' + this._index[0]) : '')).where([{
+                    [cstr._$primary]: this._data[cstr._$primary]
+                }]);
+        }
+        const r = await this._db.execute(this._sql.getSql(), this._sql.getData());
+        if (r.packet === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[remove, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (r.packet.affectedRows > 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async first(lock = false, array = false) {
+        this._sql.limit(1);
+        if (lock) {
+            this._sql.lock();
+        }
+        const r = await this._db.query(this._sql.getSql(), this._sql.getData());
+        if (r.rows === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[first, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (r.rows.length === 0) {
+            return null;
+        }
+        if (array) {
+            return r.rows[0];
+        }
+        for (const k in r.rows[0]) {
+            const v = r.rows[0][k];
+            this._data[k] = v;
+            this[k] = v;
+        }
+        return this;
+    }
+    async firstArray(lock = false) {
+        return this.first(lock, true);
+    }
+    union(f, type = '') {
+        if (f instanceof lSql.Sql) {
+            this._sql.union(f, type);
+            return this;
+        }
+        if (typeof f === 'string') {
+            f = {
+                'field': f
+            };
+        }
+        if (!Array.isArray(f)) {
+            f = [f];
+        }
+        for (let item of f) {
+            if (typeof item === 'string') {
+                item = {
+                    'field': item
+                };
+            }
+            this._sql.union(this._sql.copy(item.field, {
+                'where': item.where
+            }), type);
+        }
+        return this;
+    }
+    unionAll(f) {
+        if (f instanceof lSql.Sql) {
+            this._sql.unionAll(f);
+            return this;
+        }
+        if (typeof f === 'string') {
+            f = {
+                'field': f
+            };
+        }
+        if (!Array.isArray(f)) {
+            f = [f];
+        }
+        for (let item of f) {
+            if (typeof item === 'string') {
+                item = {
+                    'field': item
+                };
+            }
+            this._sql.unionAll(this._sql.copy(item.field, {
+                'where': item.where
+            }));
+        }
+        return this;
+    }
+    async all(key) {
+        this._total.length = 0;
+        if (this._index && this._index.length > 1) {
+            let sql = this._sql.getSql();
+            const list = key ? {} : [];
+            const limit = [this._limit[0] ?? 0, this._limit[1] ?? 200];
+            let offset = 0;
+            let remain = limit[1];
+            for (let i = 0; i < this._index.length; ++i) {
+                if (i > 0) {
+                    sql = sql.replace(/(FROM [a-zA-Z0-9`_.]+?_)[0-9_]+/, '$1' + this._index[i]);
+                }
+                const tsql = this._formatTotal(sql);
+                const tr = await this._db.query(tsql, this._sql.getData());
+                if (tr.rows === null) {
+                    return false;
+                }
+                let count = 0;
+                for (const item of tr.rows) {
+                    count += item.count;
+                }
+                this._total.push(count);
+                if (remain === 0) {
+                    continue;
+                }
+                let cz = 0;
+                if (offset > -1) {
+                    cz = limit[0] - offset;
+                    if (cz >= count) {
+                        offset += count;
+                        continue;
+                    }
+                }
+                const lsql = sql.replace(/ LIMIT [0-9 ,]/g, ` LIMIT ${cz}, ${remain}`);
+                const r = await this._db.query(lsql, this._sql.getData());
+                if (r.rows === null) {
+                    await lCore.log(this._ctr ?? {
+                        'path': '',
+                        'urlFull': '',
+                        'hostname': '',
+                        'req': null,
+                        'get': {},
+                        'cookie': {},
+                        'headers': {}
+                    }, '[all, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+                    return false;
+                }
+                if (key) {
+                    for (const row of r.rows) {
+                        const obj = new this.constructor({
+                            'db': this._db,
+                            'ctr': this._ctr,
+                            'pre': this._sql.getPre(),
+                            'row': row,
+                            'index': this._index
+                        });
+                        list[row[key]] = obj;
+                        --remain;
+                    }
+                    continue;
+                }
+                for (const row of r.rows) {
+                    const obj = new this.constructor({
+                        'db': this._db,
+                        'ctr': this._ctr,
+                        'pre': this._sql.getPre(),
+                        'row': row,
+                        'index': this._index
+                    });
+                    list.push(obj);
+                    --remain;
+                }
+                continue;
+            }
+            return Array.isArray(list) ? new Rows(list) : list;
+        }
+        const contain = this._contain ? lCore.clone(this._contain.list) : null;
+        const r = await this._db.query(this._sql.getSql(), this._sql.getData());
+        if (r.rows === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[all, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        for (const row of r.rows) {
+            if (this._contain && contain) {
+                const io = contain.indexOf(row[this._contain.key]);
+                if (io !== -1) {
+                    contain.splice(io, 1);
+                }
+            }
+        }
+        let cr = null;
+        if (this._contain && contain?.length) {
+            const csql = this._sql.copy(undefined, {
+                'where': {
+                    [this._contain.key]: this._contain.list
+                }
+            });
+            cr = await this._db.query(csql.getSql(), csql.getData());
+        }
+        if (key) {
+            const list = {};
+            for (const row of r.rows) {
+                const obj = new this.constructor({
+                    'db': this._db,
+                    'ctr': this._ctr,
+                    'pre': this._sql.getPre(),
+                    'row': row,
+                    'index': this._index
+                });
+                list[row[key]] = obj;
+            }
+            if (cr?.rows) {
+                for (const crow of cr.rows) {
+                    const obj = new this.constructor({
+                        'db': this._db,
+                        'ctr': this._ctr,
+                        'pre': this._sql.getPre(),
+                        'row': crow,
+                        'index': this._index
+                    });
+                    list[crow[key]] = obj;
+                }
+            }
+            return list;
+        }
+        const list = [];
+        for (const row of r.rows) {
+            const obj = new this.constructor({
+                'db': this._db,
+                'ctr': this._ctr,
+                'pre': this._sql.getPre(),
+                'row': row,
+                'index': this._index
+            });
+            list.push(obj);
+        }
+        if (cr?.rows) {
+            for (const crow of cr.rows) {
+                const obj = new this.constructor({
+                    'db': this._db,
+                    'ctr': this._ctr,
+                    'pre': this._sql.getPre(),
+                    'row': crow,
+                    'index': this._index
+                });
+                list.push(obj);
+            }
+        }
+        return new Rows(list);
+    }
+    async allArray(key) {
+        this._total.length = 0;
+        if (this._index && this._index.length > 1) {
+            let sql = this._sql.getSql();
+            const list = key ? {} : [];
+            const limit = [this._limit[0] ?? 0, this._limit[1] ?? 200];
+            let offset = 0;
+            let remain = limit[1];
+            for (let i = 0; i < this._index.length; ++i) {
+                if (i > 0) {
+                    sql = sql.replace(/(FROM [a-zA-Z0-9`_.]+?_)[0-9_]+/, '$1' + this._index[i]);
+                }
+                const tsql = this._formatTotal(sql);
+                const tr = await this._db.query(tsql, this._sql.getData());
+                if (tr.rows === null) {
+                    return false;
+                }
+                let count = 0;
+                for (const item of tr.rows) {
+                    count += item.count;
+                }
+                this._total.push(count);
+                if (remain === 0) {
+                    continue;
+                }
+                let cz = 0;
+                if (offset > -1) {
+                    cz = limit[0] - offset;
+                    if (cz >= count) {
+                        offset += count;
+                        continue;
+                    }
+                    offset = -1;
+                }
+                const lsql = sql.replace(/ LIMIT [0-9 ,]+/g, ` LIMIT ${cz}, ${remain}`);
+                const r = await this._db.query(lsql, this._sql.getData());
+                if (r.rows === null) {
+                    await lCore.log(this._ctr ?? {
+                        'path': '',
+                        'urlFull': '',
+                        'hostname': '',
+                        'req': null,
+                        'get': {},
+                        'cookie': {},
+                        'headers': {}
+                    }, '[allArray, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+                    return false;
+                }
+                if (key) {
+                    for (const row of r.rows) {
+                        list[row[key]] = row;
+                        --remain;
+                    }
+                    continue;
+                }
+                for (const row of r.rows) {
+                    list.push(row);
+                    --remain;
+                }
+                continue;
+            }
+            return list;
+        }
+        const contain = this._contain ? lCore.clone(this._contain.list) : null;
+        const r = await this._db.query(this._sql.getSql(), this._sql.getData());
+        if (r.rows === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[allArray, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        for (const row of r.rows) {
+            if (this._contain && contain) {
+                const io = contain.indexOf(row[this._contain.key]);
+                if (io !== -1) {
+                    contain.splice(io, 1);
+                }
+            }
+        }
+        let cr = null;
+        if (this._contain && contain?.length) {
+            const csql = this._sql.copy(undefined, {
+                'where': {
+                    [this._contain.key]: this._contain.list
+                }
+            });
+            cr = await this._db.query(csql.getSql(), csql.getData());
+        }
+        if (key) {
+            const list = {};
+            for (const row of r.rows) {
+                list[row[key]] = row;
+            }
+            if (cr?.rows) {
+                for (const crow of cr.rows) {
+                    list[crow[key]] = crow;
+                }
+            }
+            return list;
+        }
+        if (cr?.rows) {
+            for (const crow of cr.rows) {
+                r.rows.push(crow);
+            }
+        }
+        return r.rows;
+    }
+    async explain(all = false) {
+        const r = await this._db.query('EXPLAIN ' + this._sql.getSql(), this._sql.getData());
+        if (r.rows === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[explain, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return false;
+        }
+        if (!r.rows[0]) {
+            return false;
+        }
+        if (!all) {
+            return r.rows[0].type;
+        }
+        return r.rows[0];
+    }
+    _formatTotal(sql, f = '*') {
+        sql = sql
+            .replace(/ LIMIT [0-9 ,]+/g, '')
+            .replace(/ ORDER BY [\w`,. ]+(DESC|ASC)?/g, '');
+        if (sql.includes(' GROUP BY ')) {
+            return 'SELECT COUNT(0) AS `count` FROM(' + sql + ') AS `f`';
+        }
+        return sql
+            .replace(/SELECT .+? FROM/g, 'SELECT COUNT(' + this._sql.field(f) + ') AS `count` FROM');
+    }
+    async total(f = '*') {
+        if (this._total.length) {
+            let count = 0;
+            for (const item of this._total) {
+                count += item;
+            }
+            return count;
+        }
+        const sql = this._formatTotal(this._sql.getSql(), f);
+        const r = await this._db.query(sql, this._sql.getData());
+        if (r.rows === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[total, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return 0;
+        }
+        let count = 0;
+        for (const item of r.rows) {
+            count += item.count;
+        }
+        return count;
+    }
+    async count() {
+        const sql = this._sql.getSql().replace(/SELECT .+? FROM/, 'SELECT COUNT(*) AS `count` FROM');
+        const r = await this._db.query(sql, this._sql.getData());
+        if (r.rows === null) {
+            await lCore.log(this._ctr ?? {
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': null,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[count, mod] ' + lText.stringifyJson(r.error?.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            return 0;
+        }
+        let count = 0;
+        for (const item of r.rows) {
+            count += item.count;
+        }
+        return count;
+    }
+    join(f, s = [], type = 'INNER', index = '', pre = '') {
+        this._sql.join(f, s, type, index ? '_' + index : '', pre);
+        return this;
+    }
+    leftJoin(f, s, index = '', pre = '') {
+        this._sql.leftJoin(f, s, index ? '_' + index : '', pre);
+        return this;
+    }
+    rightJoin(f, s, index = '', pre = '') {
+        this._sql.rightJoin(f, s, index ? '_' + index : '', pre);
+        return this;
+    }
+    innerJoin(f, s, index = '', pre = '') {
+        this._sql.innerJoin(f, s, index ? '_' + index : '', pre);
+        return this;
+    }
+    fullJoin(f, s, index = '', pre = '') {
+        this._sql.fullJoin(f, s, index ? '_' + index : '', pre);
+        return this;
+    }
+    crossJoin(f, s, index = '', pre = '') {
+        this._sql.crossJoin(f, s, index ? '_' + index : '', pre);
+        return this;
+    }
+    having(s) {
+        this._sql.having(s);
+        return this;
+    }
+    filter(s, raw = false) {
+        const cstr = this.constructor;
+        if (cstr._soft && !raw) {
+            if (typeof s === 'string') {
+                s = '(' + s + ') AND `time_remove` = 0';
+            }
+            else if (Array.isArray(s)) {
+                s.push({
+                    'time_remove': 0
+                });
+            }
+            else {
+                s['time_remove'] = 0;
+            }
+        }
+        this._sql.where(s);
+        return this;
+    }
+    where(s, raw = false) {
+        return this.filter(s, raw);
+    }
+    by(c, d = 'DESC') {
+        this._sql.by(c, d);
+        return this;
+    }
+    group(c) {
+        this._sql.group(c);
+        return this;
+    }
+    limit(a, b = 0) {
+        this._sql.limit(a, b);
+        this._limit = [a, b];
+        return this;
+    }
+    page(count, page = 1) {
+        const a = count * (page - 1);
+        this._sql.limit(a, count);
+        this._limit = [a, count];
+        return this;
+    }
+    append(sql) {
+        this._sql.append(sql);
+        return this;
+    }
+    contain(contain) {
+        this._contain = contain;
+        return this;
+    }
+    getSql() {
+        return this._sql.getSql();
+    }
+    getData() {
+        return this._sql.getData();
+    }
+    format(sql, data) {
+        return this._sql.format(sql, data);
+    }
+    toArray() {
+        return this._data;
+    }
+    updates() {
+        const updates = {};
+        for (const k in this._updates) {
+            updates[k] = this._data[k];
+        }
+        return updates;
+    }
+    unsaved() {
+        return Object.keys(this._updates).length ? true : false;
+    }
+    langText(col, lang) {
+        const key = `${col}_${lang}`;
+        if (this._data[key]) {
+            return this._data[key];
+        }
+        if (lang !== 'en' && this._data[`${col}_en`]) {
+            return this._data[`${col}_en`];
+        }
+        for (const k in this._data) {
+            if (k.startsWith(`${col}_`) && this._data[k]) {
+                return this._data[k];
+            }
+        }
+        return '';
+    }
+    _keyGenerator() {
+        return '';
+    }
+}
+Mod._$table = '';
+Mod._$primary = 'id';
+Mod._$key = '';
+Mod._$soft = false;
+exports.default = Mod;