@maiyunnet/kebab 2.0.0

package/lib/sql.js

@@ -0,0 +1,818 @@
+"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 });
+exports.Sql = void 0;
+exports.get = get;
+exports.format = format;
+exports.aoMix = aoMix;
+exports.column = column;
+const lText = __importStar(require("~/lib/text"));
+const lCore = __importStar(require("~/lib/core"));
+const mysql2 = __importStar(require("mysql2/promise"));
+const ctr = __importStar(require("~/sys/ctr"));
+let columnToken = '';
+class Sql {
+    constructor(pre, opt = {}) {
+        this._pre = '';
+        this._sql = [];
+        this._data = [];
+        this._whereDataPosition = [0, 0];
+        this._pre = pre ?? '';
+        if (opt.data) {
+            this._data = opt.data;
+        }
+        if (opt.sql) {
+            this._sql = opt.sql;
+        }
+    }
+    insert(table) {
+        this._data = [];
+        const sql = 'INSERT INTO ' + this.field(table, this._pre);
+        this._sql = [sql];
+        return this;
+    }
+    replace(table) {
+        this._data = [];
+        const sql = 'REPLACE INTO ' + this.field(table, this._pre);
+        this._sql = [sql];
+        return this;
+    }
+    values(cs, vs = []) {
+        let sql = ' (';
+        if (Array.isArray(cs)) {
+            for (const i of cs) {
+                sql += this.field(i) + ', ';
+            }
+            sql = sql.slice(0, -2) + ') VALUES ';
+            if (!Array.isArray(vs[0])) {
+                vs = [vs];
+            }
+            for (const v of vs) {
+                sql += '(';
+                for (const v1 of v) {
+                    if (v1 === undefined || Number.isNaN(v1)) {
+                        lCore.log({
+                            'path': '',
+                            'urlFull': '',
+                            'hostname': '',
+                            'req': null,
+                            'get': {},
+                            'cookie': {},
+                            'headers': {}
+                        }, '(sql.values) value error', '-error').catch(() => {
+                        });
+                        sql += `'', `;
+                    }
+                    else if (v1 === null) {
+                        sql += 'NULL, ';
+                    }
+                    else if (typeof v1 === 'string' || typeof v1 === 'number') {
+                        sql += '?, ';
+                        this._data.push(v1);
+                    }
+                    else if (Array.isArray(v1)) {
+                        if (v1[0]?.[0]?.x === undefined && typeof v1[0] === 'string' &&
+                            v1[0].includes('(') && v1[0].includes(')')) {
+                            sql += this.field(v1[0]) + ', ';
+                            if (v1[1]) {
+                                this._data.push(...v1[1]);
+                            }
+                        }
+                        else if (v1[0]?.[0]?.y !== undefined) {
+                            sql += 'ST_POLYGONFROMTEXT(?), ';
+                            this._data.push(`POLYGON(${v1.map((item) => {
+                                return `(${item.map((it) => {
+                                    return `${it.x} ${it.y}`;
+                                }).join(', ')})`;
+                            }).join(', ')})`);
+                        }
+                        else {
+                            sql += '?, ';
+                            this._data.push(lText.stringifyJson(v1));
+                        }
+                    }
+                    else if (v1.x !== undefined) {
+                        if (v1.y !== undefined) {
+                            sql += 'ST_POINTFROMTEXT(?), ';
+                            this._data.push(`POINT(${v1.x} ${v1.y})`);
+                        }
+                        else {
+                            sql += '?, ';
+                            this._data.push(lText.stringifyJson(v1));
+                        }
+                    }
+                    else if (v1 instanceof Buffer) {
+                        sql += '?, ';
+                        this._data.push(v);
+                    }
+                    else if (this._isField(v1)) {
+                        sql += this.field(v1.value) + ', ';
+                    }
+                    else {
+                        sql += '?, ';
+                        this._data.push(lText.stringifyJson(v1));
+                    }
+                }
+                sql = sql.slice(0, -2) + '), ';
+            }
+            sql = sql.slice(0, -2);
+        }
+        else {
+            let values = '';
+            for (const k in cs) {
+                const v = cs[k];
+                sql += this.field(k) + ', ';
+                if (v === undefined || Number.isNaN(v)) {
+                    lCore.log({
+                        'path': '',
+                        'urlFull': '',
+                        'hostname': '',
+                        'req': null,
+                        'get': {},
+                        'cookie': {},
+                        'headers': {}
+                    }, '(sql.values) value error', '-error').catch(() => {
+                    });
+                    values += `'', `;
+                }
+                else if (v === null) {
+                    values += 'NULL, ';
+                }
+                else if (typeof v === 'string' || typeof v === 'number') {
+                    values += '?, ';
+                    this._data.push(v);
+                }
+                else if (Array.isArray(v)) {
+                    if (v[0]?.[0]?.x === undefined && typeof v[0] === 'string' &&
+                        v[0].includes('(') && v[0].includes(')')) {
+                        values += this.field(v[0]) + ', ';
+                        if (v[1] !== undefined) {
+                            this._data.push(...v[1]);
+                        }
+                    }
+                    else if (v[0]?.[0]?.y !== undefined) {
+                        values += 'ST_POLYGONFROMTEXT(?), ';
+                        this._data.push(`POLYGON(${v.map((item) => {
+                            return `(${item.map((it) => {
+                                return `${it.x} ${it.y}`;
+                            }).join(', ')})`;
+                        }).join(', ')})`);
+                    }
+                    else {
+                        values += '?, ';
+                        this._data.push(lText.stringifyJson(v));
+                    }
+                }
+                else if (v.x !== undefined) {
+                    if (v.y !== undefined) {
+                        values += 'ST_POINTFROMTEXT(?), ';
+                        this._data.push(`POINT(${v.x} ${v.y})`);
+                    }
+                    else {
+                        values += '?, ';
+                        this._data.push(lText.stringifyJson(v));
+                    }
+                }
+                else if (v instanceof Buffer) {
+                    values += '?, ';
+                    this._data.push(v);
+                }
+                else if (this._isField(v)) {
+                    values += this.field(v.value) + ', ';
+                }
+                else {
+                    values += '?, ';
+                    this._data.push(lText.stringifyJson(v));
+                }
+            }
+            sql = sql.slice(0, -2) + ') VALUES (' + values.slice(0, -2) + ')';
+        }
+        this._sql.push(sql);
+        return this;
+    }
+    notExists(table, insert, where) {
+        let sql = '(';
+        const values = [];
+        for (const field in insert) {
+            const val = insert[field];
+            sql += this.field(field) + ', ';
+            values.push(val);
+        }
+        sql = sql.slice(0, -2) + ') SELECT ';
+        for (const value of values) {
+            if (Array.isArray(value)) {
+                sql += value[0] + ', ';
+                this._data.push(...value[1]);
+            }
+            else {
+                sql += '?, ';
+                this._data.push(value);
+            }
+        }
+        sql = sql.slice(0, -2) + ' FROM DUAL WHERE NOT EXISTS (SELECT `id` FROM ' + this.field(table, this._pre) + ' WHERE ' + this._whereSub(where) + ')';
+        this._sql.push(sql);
+        return this;
+    }
+    duplicate(s) {
+        if (Array.isArray(s) ? s.length : Object.keys(s).length) {
+            const sql = ' ON DUPLICATE KEY UPDATE ' + this._updateSub(s);
+            this._sql.push(sql);
+        }
+        return this;
+    }
+    select(c, f) {
+        this._data = [];
+        let sql = 'SELECT ';
+        if (typeof c === 'string') {
+            sql += this.field(c);
+        }
+        else {
+            for (const i of c) {
+                if (Array.isArray(i)) {
+                    sql += this.field(i[0]) + ', ';
+                    this._data.push(...i[1]);
+                }
+                else {
+                    sql += this.field(i) + ', ';
+                }
+            }
+            sql = sql.slice(0, -2);
+        }
+        sql += ' FROM ';
+        if (typeof f === 'string') {
+            sql += this.field(f, this._pre);
+        }
+        else {
+            for (const i of f) {
+                sql += this.field(i, this._pre) + ', ';
+            }
+            sql = sql.slice(0, -2);
+        }
+        this._sql = [sql];
+        return this;
+    }
+    update(f, s) {
+        this._data = [];
+        const sql = `UPDATE ${this.field(f, this._pre)} SET ${this._updateSub(s)}`;
+        this._sql = [sql];
+        return this;
+    }
+    _updateSub(s) {
+        s = aoMix(s);
+        let sql = '';
+        for (const k in s) {
+            const v = s[k];
+            if (/^[0-9]+$/.test(k)) {
+                const nv = v[2];
+                const isf = this._isField(nv);
+                if (isf) {
+                    if (v[1] === '=') {
+                        sql += this.field(v[0]) + ' = ' + this.field(nv.value) + ', ';
+                    }
+                    else {
+                        sql += this.field(v[0]) + ' = ' + this.field(v[0]) + ' ' + v[1] + ' ' + this.field(nv.value) + ', ';
+                    }
+                }
+                else {
+                    if (v[1] === '=') {
+                        sql += this.field(v[0]) + ' = ?, ';
+                    }
+                    else {
+                        sql += this.field(v[0]) + ' = ' + this.field(v[0]) + ' ' + v[1] + ' ?, ';
+                    }
+                    this._data.push(nv);
+                }
+            }
+            else {
+                sql += this.field(k) + ' = ';
+                if (v === undefined || Number.isNaN(v)) {
+                    lCore.log({
+                        'path': '',
+                        'urlFull': '',
+                        'hostname': '',
+                        'req': null,
+                        'get': {},
+                        'cookie': {},
+                        'headers': {}
+                    }, '(sql._updateSub) value error, key: ' + k, '-error').catch(() => {
+                    });
+                    sql += '"", ';
+                }
+                else if (v === null) {
+                    sql += 'NULL, ';
+                }
+                else if (typeof v === 'string' || typeof v === 'number') {
+                    sql += '?, ';
+                    this._data.push(v);
+                }
+                else if (Array.isArray(v)) {
+                    if (v[0]?.[0]?.x === undefined && typeof v[0] === 'string' &&
+                        v[0].includes('(') && v[0].includes(')')) {
+                        sql += this.field(v[0]) + ', ';
+                        if (v[1] !== undefined) {
+                            this._data.push(...v[1]);
+                        }
+                    }
+                    else if (v[0]?.[0]?.y !== undefined) {
+                        sql += 'ST_POLYGONFROMTEXT(?), ';
+                        this._data.push(`POLYGON(${v.map((item) => {
+                            return `(${item.map((it) => {
+                                return `${it.x} ${it.y}`;
+                            }).join(', ')})`;
+                        }).join(', ')})`);
+                    }
+                    else {
+                        sql += '?, ';
+                        this._data.push(lText.stringifyJson(v));
+                    }
+                }
+                else if (v.x !== undefined) {
+                    if (v.y !== undefined) {
+                        sql += 'ST_POINTFROMTEXT(?), ';
+                        this._data.push(`POINT(${v.x} ${v.y})`);
+                    }
+                    else {
+                        if (this._isField(v)) {
+                            sql += this.field(v.value) + ', ';
+                        }
+                        else {
+                            sql += '?, ';
+                            this._data.push(lText.stringifyJson(v));
+                        }
+                    }
+                }
+                else if (v instanceof Buffer) {
+                    sql += '?, ';
+                    this._data.push(v);
+                }
+                else if (this._isField(v)) {
+                    sql += this.field(v.value) + ', ';
+                }
+                else {
+                    sql += '?, ';
+                    this._data.push(lText.stringifyJson(v));
+                }
+            }
+        }
+        sql = sql.slice(0, -2);
+        return sql;
+    }
+    delete(f) {
+        this._data = [];
+        this._sql = ['DELETE FROM ' + this.field(f, this._pre)];
+        return this;
+    }
+    union(lsql, type = '') {
+        this._data = this._data.concat(lsql.getData());
+        this._sql.push(' UNION ' + (type ? type + ' ' : ''));
+        this._sql.push(lsql.getSql());
+        return this;
+    }
+    unionAll(lsql) {
+        return this.union(lsql, 'ALL');
+    }
+    join(f, s = [], type = 'INNER', suf = '', pre = '') {
+        let field = this.field(f, pre || this._pre, suf ? ('#' + suf) : '');
+        if (pre) {
+            field = field.replace(new RegExp(`AS \`${pre}(.+?)\``), `AS \`${this._pre}$1\``);
+        }
+        let sql = ' ' + type + ' JOIN ' + field;
+        if (Array.isArray(s) ? s.length : Object.keys(s).length) {
+            sql += ' ON ' + this._whereSub(s);
+        }
+        this._sql.push(sql);
+        return this;
+    }
+    leftJoin(f, s = [], suf = '', pre = '') {
+        return this.join(f, s, 'LEFT', suf, pre);
+    }
+    rightJoin(f, s = [], suf = '', pre = '') {
+        return this.join(f, s, 'RIGHT', suf, pre);
+    }
+    innerJoin(f, s = [], suf = '', pre = '') {
+        return this.join(f, s, 'INNER', suf, pre);
+    }
+    fullJoin(f, s = [], suf = '', pre = '') {
+        return this.join(f, s, 'FULL', suf, pre);
+    }
+    crossJoin(f, s = [], suf = '', pre = '') {
+        return this.join(f, s, 'CROSS', suf, pre);
+    }
+    having(s = '') {
+        if (typeof s === 'string') {
+            if (s !== '') {
+                this._sql.push(' HAVING ' + s);
+            }
+        }
+        else {
+            if (s.length) {
+                const whereSub = this._whereSub(s);
+                if (whereSub !== '') {
+                    this._sql.push(' HAVING ' + whereSub);
+                }
+            }
+        }
+        return this;
+    }
+    where(s) {
+        this._whereDataPosition[0] = this._data.length;
+        if (typeof s === 'string') {
+            if (s !== '') {
+                this._sql.push(' WHERE ' + s);
+                this._whereDataPosition[1] = this._data.length;
+            }
+        }
+        else {
+            let go = false;
+            if (Array.isArray(s)) {
+                if (s.length) {
+                    go = true;
+                }
+            }
+            else {
+                if (Object.keys(s).length) {
+                    go = true;
+                }
+            }
+            if (go) {
+                const whereSub = this._whereSub(s);
+                if (whereSub !== '') {
+                    this._sql.push(' WHERE ' + whereSub);
+                }
+            }
+            this._whereDataPosition[1] = this._data.length;
+        }
+        return this;
+    }
+    _whereSub(s, data) {
+        if (!data) {
+            data = this._data;
+        }
+        s = aoMix(s);
+        let sql = '';
+        for (const k in s) {
+            const v = s[k];
+            if (/^[0-9]+$/.test(k)) {
+                if (v[2] === undefined) {
+                    sql += this.field(v[0]) + ' AND ';
+                    if (v[1] !== undefined) {
+                        data.push(...v[1]);
+                    }
+                }
+                else if (v[2] === null) {
+                    let opera = v[1];
+                    if (opera === '!=' || opera === '!==' || opera === '<>') {
+                        opera = 'IS NOT';
+                    }
+                    else if (opera === '=' || opera === '==' || opera === '===') {
+                        opera = 'IS';
+                    }
+                    else {
+                        opera = opera.toUpperCase();
+                    }
+                    sql += this.field(v[0]) + ' ' + opera + ' NULL AND ';
+                }
+                else if (Array.isArray(v[2])) {
+                    sql += this.field(v[0]) + ' ' + v[1].toUpperCase() + ' (';
+                    for (const v1 of v[2]) {
+                        sql += '?, ';
+                        data.push(v1);
+                    }
+                    sql = sql.slice(0, -2) + ') AND ';
+                }
+                else {
+                    const nv = v[2];
+                    const isf = this._isField(nv);
+                    if (isf) {
+                        sql += this.field(v[0]) + ' ' + v[1] + ' ' + this.field(nv.value) + ' AND ';
+                    }
+                    else {
+                        sql += this.field(v[0]) + ' ' + v[1] + ' ? AND ';
+                        data.push(nv);
+                    }
+                }
+            }
+            else {
+                if (k.startsWith('$')) {
+                    const sp = ' ' + k.slice(1).split('-')[0].toUpperCase() + ' ';
+                    sql += '(';
+                    for (let v1 of v) {
+                        v1 = aoMix(v1);
+                        if (Object.keys(v1).length > 1) {
+                            sql += '(' + this._whereSub(v1, data) + ')' + sp;
+                        }
+                        else {
+                            sql += this._whereSub(v1, data) + sp;
+                        }
+                    }
+                    sql = sql.slice(0, -sp.length) + ') AND ';
+                }
+                else {
+                    if (v === null) {
+                        sql += this.field(k) + ' IS NULL AND ';
+                    }
+                    else if (typeof v === 'string' || typeof v === 'number') {
+                        sql += this.field(k) + ' = ? AND ';
+                        data.push(v);
+                    }
+                    else if (this._isField(v)) {
+                        sql += this.field(k) + ' = ' + this.field(v.value) + ' AND ';
+                    }
+                    else {
+                        if (v.length > 0) {
+                            sql += this.field(k) + ' IN (';
+                            for (const v1 of v) {
+                                sql += '?, ';
+                                data.push(v1);
+                            }
+                            sql = sql.slice(0, -2) + ') AND ';
+                        }
+                        else {
+                            sql += this.field(k) + ' IN (NULL) AND ';
+                        }
+                    }
+                }
+            }
+        }
+        if (sql === '') {
+            return '';
+        }
+        return sql.slice(0, -5);
+    }
+    by(c, d = 'DESC') {
+        let sql = ' ORDER BY ';
+        if (typeof c === 'string') {
+            sql += this.field(c) + ' ' + d;
+        }
+        else {
+            for (const v of c) {
+                if (typeof v === 'string' || typeof v === 'number') {
+                    sql += this.field(v) + ' ' + d + ', ';
+                }
+                else {
+                    sql += this.field(v[0]) + ' ' + v[1] + ', ';
+                }
+            }
+            sql = sql.slice(0, -2);
+        }
+        this._sql.push(sql);
+        return this;
+    }
+    group(c) {
+        let sql = ' GROUP BY ';
+        if (typeof c === 'string') {
+            sql += this.field(c);
+        }
+        else {
+            for (const v of c) {
+                sql += this.field(v) + ', ';
+            }
+            sql = sql.slice(0, -2);
+        }
+        this._sql.push(sql);
+        return this;
+    }
+    limit(a, b = 0) {
+        this._sql.push(' LIMIT ' + a.toString() + (b > 0 ? ', ' + b.toString() : ''));
+        return this;
+    }
+    lock() {
+        this._sql.push(' FOR UPDATE');
+        return this;
+    }
+    copy(f, opt = {}) {
+        const sql = lCore.clone(this._sql);
+        const data = lCore.clone(this._data);
+        if (opt.where !== undefined) {
+            if (typeof opt.where === 'string') {
+                for (let i = 0; i < sql.length; ++i) {
+                    if (!sql[i].startsWith(' WHERE ')) {
+                        continue;
+                    }
+                    sql[i] = opt.where ? (' WHERE ' + opt.where) : '';
+                    data.splice(this._whereDataPosition[0], this._whereDataPosition[1] - this._whereDataPosition[0]);
+                    break;
+                }
+            }
+            else {
+                let go = false;
+                if (Array.isArray(opt.where)) {
+                    if (opt.where.length) {
+                        go = true;
+                    }
+                }
+                else {
+                    if (Object.keys(opt.where).length) {
+                        go = true;
+                    }
+                }
+                for (let i = 0; i < sql.length; ++i) {
+                    if (!sql[i].startsWith(' WHERE ')) {
+                        continue;
+                    }
+                    if (go) {
+                        const d = [];
+                        sql[i] = ' WHERE ' + this._whereSub(opt.where, d);
+                        data.splice(this._whereDataPosition[0], this._whereDataPosition[1] - this._whereDataPosition[0], ...d);
+                    }
+                    else {
+                        sql.splice(i, 1);
+                        data.splice(this._whereDataPosition[0], this._whereDataPosition[1] - this._whereDataPosition[0]);
+                    }
+                    break;
+                }
+            }
+        }
+        if (f && sql[0]) {
+            let table = '';
+            if (typeof f === 'string') {
+                table = this.field(f, this._pre);
+            }
+            else {
+                for (const i of f) {
+                    table += this.field(i, this._pre) + ', ';
+                }
+                table = table.slice(0, -2);
+            }
+            sql[0] = sql[0].replace(/FROM [`\w, ]+/, 'FROM ' + table);
+        }
+        return get(this.getPre(), {
+            'data': data,
+            'sql': sql
+        });
+    }
+    getSql() {
+        return this._sql.join('');
+    }
+    getData() {
+        return this._data;
+    }
+    getPre() {
+        return this._pre;
+    }
+    format(sql, data) {
+        return mysql2.format(sql ?? this.getSql(), data ?? this.getData());
+    }
+    append(sql) {
+        this._sql.push(sql);
+        return this;
+    }
+    field(str, pre = '', suf = '') {
+        let left = '';
+        let right = '';
+        if (Array.isArray(str)) {
+            this._data.push(...str[1]);
+            return this.field(str[0]);
+        }
+        if (typeof str === 'number') {
+            str = str.toString();
+        }
+        str = str.trim();
+        str = str.replace(/ {2,}/g, ' ');
+        str = str.replace(/ +([),])/g, ' $1');
+        str = str.replace(/([(,]) +/g, '$1 ');
+        str = str.replace(/(\W)(JOIN|WHERE|UNION)(\W)/ig, '$1$3');
+        let sufAs = false;
+        if (suf.startsWith('#')) {
+            suf = suf.slice(1);
+            sufAs = true;
+        }
+        const loStr = str.toLowerCase();
+        const asPos = loStr.indexOf(' as ');
+        if (asPos === -1) {
+            let spacePos = str.lastIndexOf(' ');
+            if (!/^[a-zA-Z_)]$/.test(str[spacePos - 1])) {
+                spacePos = -1;
+            }
+            if (spacePos !== -1) {
+                const spaceRight = str.slice(spacePos + 1);
+                if (/^[a-zA-Z_`][\w`]*$/.test(spaceRight)) {
+                    left = str.slice(0, spacePos);
+                    right = spaceRight;
+                }
+                else {
+                    left = str;
+                    right = '';
+                }
+            }
+            else {
+                left = str;
+                right = '';
+            }
+        }
+        else {
+            left = str.slice(0, asPos);
+            right = str.slice(asPos + 4);
+        }
+        if (right) {
+            if (right.startsWith('`')) {
+                right = '`' + pre + right.slice(1);
+            }
+            else {
+                right = '`' + pre + right + '`';
+            }
+            right = ' AS ' + right;
+        }
+        else {
+            if (sufAs) {
+                right = ' AS ' + this.field(left, pre);
+            }
+        }
+        if (/^[\w`_.*]+$/.test(left)) {
+            const l = left.split('.');
+            if (l[0] === '*') {
+                return '*' + right;
+            }
+            if (l[0].startsWith('`')) {
+                l[0] = l[0].replace(/`/g, '');
+            }
+            if (l[1] === undefined) {
+                if (/^[A-Z0-9_]+$/.test(l[0])) {
+                    return l[0] + right;
+                }
+                return '`' + pre + l[0] + suf + '`' + right;
+            }
+            const w = l[1] === '*' ? '*' : (l[1].startsWith('`') ? l[1] : ('`' + l[1] + '`'));
+            return '`' + this._pre + l[0] + suf + '`.' + w + right;
+        }
+        else {
+            return left.replace(/(^|[(, ])([a-zA-Z`_][\w`_.]*)(?=[), ]|$)/g, (t, t1, t2) => {
+                return t1 + this.field(t2, pre, suf);
+            }) + right;
+        }
+    }
+    _isField(arg) {
+        if (arg.type !== 'column' || arg.token !== columnToken || arg.value === undefined) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.Sql = Sql;
+function get(ctrPre, opt = {}) {
+    return new Sql(ctrPre instanceof ctr.Ctr ? ctrPre.getPrototype('_config').sql.pre : ctrPre, opt);
+}
+function format(sql, data) {
+    return mysql2.format(sql, data);
+}
+function aoMix(arr) {
+    if (!Array.isArray(arr)) {
+        return arr;
+    }
+    const mix = {};
+    let i = 0;
+    for (const v of arr) {
+        if (Array.isArray(v)) {
+            mix[i] = v;
+            ++i;
+        }
+        else {
+            for (const k in v) {
+                mix[k] = v[k];
+            }
+        }
+    }
+    return mix;
+}
+function column(field) {
+    if (!columnToken) {
+        columnToken = lCore.random(8, lCore.RANDOM_LUNS);
+    }
+    return {
+        'token': columnToken,
+        'type': 'column',
+        'value': field
+    };
+}