jj.js 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.19.0 / 2025-12-11
+1. 修改app.listen监听逻辑
+2. 新增支持sqlite数据库
+3. 新增test代码
+
 # v0.18.0 / 2025-03-20
 1. 升级依赖koa版本到v2.16.0
 2. 修复模板路径解析bug

package/lib/app.js

@@ -12,11 +12,17 @@ const pjson = require('../package.json');
  */
 class App extends Koa
 {
-    /**
-     * @override
-     * @param {...any} args - listen(port, ip, callback(err){})
-     */
-    listen(...args) {
+    constructor(beforeUse, options) {
+        if(typeof beforeUse === 'function') {
+            super(options);
+            this.use(beforeUse);
+        } else {
+            super(beforeUse);
+        }
+        this._init();
+    }
+
+    _init() {
         // storage
         this.use(async (ctx, next) => {
             await storage.run({}, async() => {
@@ -63,9 +69,6 @@ class App extends Koa
             const jsconfigFile = path.join(cfg_app.base_dir, 'jsconfig.json');
             isFileSync(jsconfigFile) && require('./types')();
         }
-
-        // server
-        return super.listen(...args);
     }
 }
 

package/lib/config.js

@@ -34,9 +34,14 @@ const db = {
         user      : 'root', // 数据库用户名
         password  : '', // 数据库密码
         port      : '', // 数据库连接端口
-        charset   : 'utf8', // 数据库编码默认采用utf8
+        charset   : 'utf8mb4', // 数据库编码默认采用utf8mb4
         prefix    : 'jj_' // 数据库表前缀
-    }
+    },
+    sqlite: {
+        type      : 'sqlite', // 数据库类型
+        database  : ':memory:', // 数据库文件绝对地址，支持:memory:内存数据库
+        prefix    : 'jj_' // 数据库表前缀
+    },
 }
 
 const log = {

package/lib/db/mysql.js

@@ -0,0 +1,290 @@
+const Sql = require('./sql');
+
+/**
+ * @typedef {import('../../types').Pool} Pool
+ * @typedef {import('../../types').PoolConfig} PoolConfig
+ * @typedef {import('../../types').PoolConnection} PoolConnection
+ * @typedef {import('../../types').FieldInfo} FieldInfo
+ * @typedef {Map<any, Pool>} PoolMap
+ */
+
+//连接池
+/**
+ * @type {PoolMap}
+ */
+const pool = new Map();
+//事务连接
+const trans = new Map();
+//事务嵌套
+const nest = new Map();
+
+/**
+ * @extends Sql
+ */
+class Mysql extends Sql
+{
+    /**
+     * 连接数据库连接池
+     * @public
+     * @param {PoolConfig} config - 数据库配置标识或连接参数
+     * @returns {Promise<this>}
+}
+     */
+    async connect(config={}) {
+        this._config = config;
+
+        if(!pool.has(this._config)) {
+            const cur_pool = require('mysql').createPool(this._config);
+            pool.set(this._config, cur_pool);
+            this.$logger.sql(`MYSQL连接池创建成功：{all: ${pool.size}}`);
+        }
+        
+        return this;
+    }
+
+    /**
+     * 关闭数据库连接池
+     * @public
+     * @returns {Promise}
+     */
+    async close() {
+        return new Promise((resolve, reject) => {
+            if(pool.has(this._config)) {
+                pool.get(this._config).end(err => {
+                    if(err) {
+                        const message = 'MYSQL连接池销毁失败：' + err.message;
+                        this.$logger.sql(message);
+                        this.$logger.error(message);
+                        reject(new Error('DbError: ' + message));
+                    } else {
+                        pool.delete(this._config);
+                        this.$logger.sql(`MYSQL连接池销毁成功：{poolTotal: ${pool.size}}`);
+                        resolve(this);
+                    }
+                });
+            } else {
+                resolve(this);
+            }
+        });
+    }
+
+    /**
+     * 释放数据库连接
+     * @public
+     * @param {PoolConnection} conn - 数据库连接
+     */
+    release(conn) {
+        try {
+            conn.release();
+            this.$logger.sql('释放数据库连接！');
+        } catch(e) {
+            const message = '释放数据库出错：' + e.message;
+            this.$logger.sql(message);
+            this.$logger.error(message);
+        }
+    }
+
+    /**
+     * 获取数据库连接
+     * @private
+     * @param {Pool} p 
+     * @returns {Promise<PoolConnection>}
+     */
+    async _creatConnect(p) {
+        return new Promise((resolve, reject) => {
+            p.getConnection((err, connection) => {
+                if(err) {
+                    const message = '获取数据库连接失败：' + err.message;
+                    this.$logger.sql(message);
+                    this.$logger.error(message);
+                    reject(new Error('DbError: ' + message));
+                } else {
+                    this.$logger.sql(`获取数据库连接：{limit: ${p.config.connectionLimit}, all: ${p._allConnections.length}, acquiring: ${p._acquiringConnections.length}, free: ${p._freeConnections.length}, queue: ${p._connectionQueue.length}}`);
+                    resolve(connection);
+                }
+            });
+        });
+    }
+
+    /**
+     * 获取数据库连接
+     * @private
+     * @returns {Promise<PoolConnection>}
+     */
+    async _getConnect() {
+        return trans.get(this.ctx) || await this._creatConnect(pool.get(this._config));
+    }
+
+    /**
+     * 开启事务
+     * @public
+     * @param {function} fun
+     * @returns {Promise<string>}
+     */
+    async startTrans(fun) {
+        const conn = await this._getConnect();
+        trans.set(this.ctx, conn);
+        let trans_nest = nest.get(conn) || 0;
+        nest.set(conn, ++trans_nest);
+        if(trans_nest > 1) {
+            const message = `开启事务成功：{nest:${trans_nest}}`;
+            this.$logger.sql(message);
+            if(typeof fun === 'function') {
+                try {
+                    await fun();
+                    await this.commit();
+                } catch(e) {
+                    await this.rollback();
+                    throw e;
+                }
+            }
+            return message;
+        }
+
+        return new Promise((resolve, reject) => {
+            conn.beginTransaction(async err => {
+                if(err) {
+                    const message = '开启事务失败：' + err.message;
+                    this.$logger.sql(message);
+                    this.$logger.error(message);
+                    reject(new Error('DbError: ' + message));
+                } else {
+                    const message = '开启事务成功！';
+                    this.$logger.sql(message);
+                    if(typeof fun === 'function') {
+                        try {
+                            await fun();
+                            await this.commit();
+                            resolve('事务执行成功！');
+                        } catch(e) {
+                            await this.rollback();
+                            reject(e);
+                        }
+                    }
+                    resolve(message);
+                }
+            });
+        });
+    }
+
+    /**
+     * 事务回滚
+     * @public
+     * @returns {Promise<string>}
+     */
+    async rollback() {
+        const conn = await this._getConnect();
+        const trans_nest = nest.get(conn) || 0;
+        if(trans_nest > 1) {
+            nest.set(conn, trans_nest - 1);
+            const message = `事务回滚成功：{nest:${trans_nest}}`;
+            this.$logger.sql(message);
+            return message;
+        } else {
+            nest.delete(conn);
+        }
+
+        return new Promise((resolve, reject) => {
+            conn.rollback(err => {
+                if(err) {
+                    reject(new Error('DbError: ' + err.message));
+                } else {
+                    trans.delete(this.ctx);
+                    const message = '事务回滚成功！';
+                    this.$logger.sql(message);
+                    this.release(conn);
+                    resolve(message);
+                }
+            });
+        });
+    }
+
+    /**
+     * 提交事务
+     * @public
+     * @returns {Promise<string>}
+     */
+    async commit() {
+        const conn = await this._getConnect();
+        const trans_nest = nest.get(conn) || 0;
+        if(trans_nest > 1) {
+            nest.set(conn, trans_nest - 1);
+            const message = `事务提交成功：{nest:${trans_nest}}`;
+            this.$logger.sql(message);
+            return message;
+        } else {
+            nest.delete(conn);
+        }
+
+        return new Promise((resolve, reject) => {
+            conn.commit(err => {
+                if(err) {
+                    const message = '事务提交失败：' + err.message;
+                    this.$logger.sql(message);
+                    this.$logger.error(message);
+                    this.rollback();
+                    reject(new Error('DbError: ' + message));
+                } else {
+                    trans.delete(this.ctx);
+                    const message = '事务提交成功！';
+                    this.$logger.sql(message);
+                    this.release(conn);
+                    resolve(message);
+                }
+            });
+        });
+    }
+
+    /**
+     * 执行sql查询
+     * @public
+     * @param {string} sql - sql语句或参数
+     * @param {*} params - sql参数
+     * @returns {Promise}
+     */
+    async query(sql, params) {
+        params || (params = []);
+        const conn = await this._getConnect();
+
+        return new Promise((resolve, reject) => {
+            conn.query(sql, params, (err, data) => {
+                if(err) {
+                    const message = '数据操作失败，' + err.message + "\nSQL：" + this.format(sql, params);
+                    this.$logger.sql(message);
+                    this.$logger.error(message);
+                    reject(new Error('DbError: ' + message));
+                } else {
+                    this.$logger.sql('数据操作成功，SQL：' + this.format(sql, params));
+                    resolve(data);
+                }
+                if(!trans.has(this.ctx)) {
+                    this.release(conn);
+                }
+            });
+        });
+    }
+
+    /**
+     * 序列化sql语句
+     * @public
+     * @param {string} sql - sql语句或参数
+     * @param {*} params - sql参数
+     * @returns {string}
+     */
+    format(sql, params) {
+        params || (params = []);
+        return require('mysql').format(sql, params);
+    }
+
+    /**
+     * 获取数据表信息
+     * @public
+     * @param {string} tableName - 表名字
+     * @returns {Promise<FieldInfo[]>}
+     */
+    async tableInfo(tableName) {
+        return await this.query(`show columns from ?`, [tableName]);
+    }
+}
+
+module.exports = Mysql;

package/lib/db/sql.js

@@ -0,0 +1,106 @@
+/**
+ * @typedef {import('../../types').Logger} Logger
+ * @typedef {import('../../types').FieldInfo} FieldInfo
+ */
+
+class Sql
+{
+    /**
+     * @public
+     * @param {object} ctx
+     * @param {Logger} logger
+     */
+    constructor(ctx, logger) {
+        this.ctx = ctx;
+        this.$logger = logger;
+    }
+
+    /**
+     * 连接数据库
+     * @public
+     * @param {object} config - 数据库连接参数
+     * @returns {Promise<this>}
+     */
+    async connect(config={}) {
+        return this;
+    }
+
+    /**
+     * 关闭数据库
+     * @public
+     * @returns {Promise<this>}
+     */
+    async close() {
+        return this;
+    }
+
+    /**
+     * 释放数据库连接
+     * @public
+     * @param {object} conn - 数据库连接
+     */
+    release(conn) {
+    }
+
+    /**
+     * 开启事务
+     * @public
+     * @param {function} [fun] 
+     * @returns {Promise<string>}
+     */
+    async startTrans(fun) {
+        return '开启事务成功';
+    }
+
+    /**
+     * 事务回滚
+     * @public
+     * @returns {Promise<string>}
+     */
+    async rollback() {
+        return '事务回滚成功';
+    }
+
+    /**
+     * 提交事务
+     * @public
+     * @returns {Promise<string>}
+     */
+    async commit() {
+        return '事务提交成功';
+    }
+
+    /**
+     * 执行sql查询
+     * @public
+     * @param {string} sql - sql语句或参数
+     * @param {*} params - sql参数
+     * @returns {Promise}
+     */
+    async query(sql, params) {
+    }
+
+    /**
+     * 序列化sql语句
+     * @public
+     * @param {string} sql - sql语句或参数
+     * @param {*} params - sql参数
+     * @returns {string}
+     */
+    format(sql, params) {
+        params || (params = []);
+        return `${sql} ${params.map(item => item.join('=')).join(', ')}`;
+    }
+
+    /**
+     * 获取数据表信息
+     * @public
+     * @param {string} tableName - 表名字
+     * @returns {Promise<FieldInfo[]>}
+     */
+    async tableInfo(tableName) {
+        return await this.query(`show columns from ?`, [tableName]);
+    }
+}
+
+module.exports = Sql;

package/lib/db/sqlite.js

@@ -0,0 +1,284 @@
+const {app: cfg_app} = require('../config');
+const Sql = require('./sql');
+
+/**
+ * @typedef {import('sqlite3').Database} Database
+ * @typedef {import('../../types').FieldInfo} FieldInfo
+ * @typedef {Map<any, Database>} ConnectionMap
+ */
+
+//数据库连接
+/**
+ * @type {ConnectionMap}
+ */
+const connections = new Map();
+//事务连接
+const trans = new Map();
+//事务嵌套
+const nest = new Map();
+
+/**
+ * @extends Sql
+ */
+class Sqlite extends Sql
+{
+    /**
+     * 连接数据库
+     * @public
+     * @param {object} config - 数据库配置标识或连接参数
+     * @returns {Promise<this>}
+     */
+    async connect(config={}) {
+        this._config = config;
+
+        let connection = connections.get(this._config);
+        if(!connection) {
+            const sqlite3 = cfg_app.app_debug ? require('sqlite3').verbose() : require('sqlite3');
+            connection = new sqlite3.Database(this._config.database);
+            connections.set(this._config, connection);
+            this.$logger.sql(`SQLITE数据库连接创建成功：{all: ${connections.size}}`);
+        }
+        
+        return this;
+    }
+
+    /**
+     * 关闭数据库连接
+     * @public
+     * @returns {Promise}
+     */
+    async close() {
+        return new Promise((resolve, reject) => {
+            if(connections.has(this._config)) {
+                const connection = connections.get(this._config);
+                connection.close(err => {
+                    if(err) {
+                        const message = 'SQLITE数据库连接关闭失败：' + err.message;
+                        this.$logger.sql(message);
+                        this.$logger.error(message);
+                        reject(new Error('DbError: ' + message));
+                    } else {
+                        connections.delete(this._config);
+                        this.$logger.sql(`SQLITE数据库连接关闭成功：{connectionTotal: ${connections.size}}`);
+                        resolve(this);
+                    }
+                });
+            } else {
+                resolve(this);
+            }
+        });
+    }
+
+    /**
+     * 获取数据库连接
+     * @private
+     * @returns {Promise<Database>}
+     */
+    async _getConnect() {
+        return trans.get(this.ctx) || connections.get(this._config);
+    }
+
+    /**
+     * 开启事务
+     * @public
+     * @param {function} fun
+     * @returns {Promise<string>}
+     */
+    async startTrans(fun) {
+        const conn = await this._getConnect();
+        trans.set(this.ctx, conn);
+        let trans_nest = nest.get(conn) || 0;
+        nest.set(conn, ++trans_nest);
+        if(trans_nest > 1) {
+            const message = `开启事务成功：{nest:${trans_nest}}`;
+            this.$logger.sql(message);
+            if(typeof fun === 'function') {
+                try {
+                    await fun();
+                    await this.commit();
+                } catch(e) {
+                    await this.rollback();
+                    throw e;
+                }
+            }
+            return message;
+        }
+
+        return new Promise((resolve, reject) => {
+            conn.run('BEGIN TRANSACTION;', async err => {
+                if(err) {
+                    const message = '开启事务失败：' + err.message;
+                    this.$logger.sql(message);
+                    this.$logger.error(message);
+                    reject(new Error('DbError: ' + message));
+                } else {
+                    const message = '开启事务成功！';
+                    this.$logger.sql(message);
+                    if(typeof fun === 'function') {
+                        try {
+                            await fun();
+                            await this.commit();
+                            resolve('事务执行成功！');
+                        } catch(e) {
+                            await this.rollback();
+                            reject(e);
+                        }
+                    }
+                    resolve(message);
+                }
+            });
+        });
+    }
+
+    /**
+     * 事务回滚
+     * @public
+     * @returns {Promise<string>}
+     */
+    async rollback() {
+        const conn = await this._getConnect();
+        const trans_nest = nest.get(conn) || 0;
+        if(trans_nest > 1) {
+            nest.set(conn, trans_nest - 1);
+            const message = `事务回滚成功：{nest:${trans_nest}}`;
+            this.$logger.sql(message);
+            return message;
+        } else {
+            nest.delete(conn);
+        }
+
+        return new Promise((resolve, reject) => {
+            conn.run('ROLLBACK;', err => {
+                if(err) {
+                    reject(new Error('DbError: ' + err.message));
+                } else {
+                    trans.delete(this.ctx);
+                    const message = '事务回滚成功！';
+                    this.$logger.sql(message);
+                    resolve(message);
+                }
+            });
+        });
+    }
+
+    /**
+     * 提交事务
+     * @public
+     * @returns {Promise<string>}
+     */
+    async commit() {
+        const conn = await this._getConnect();
+        const trans_nest = nest.get(conn) || 0;
+        if(trans_nest > 1) {
+            nest.set(conn, trans_nest - 1);
+            const message = `事务提交成功：{nest:${trans_nest}}`;
+            this.$logger.sql(message);
+            return message;
+        } else {
+            nest.delete(conn);
+        }
+
+        return new Promise((resolve, reject) => {
+            conn.run('COMMIT;', err => {
+                if(err) {
+                    const message = '事务提交失败：' + err.message;
+                    this.$logger.sql(message);
+                    this.$logger.error(message);
+                    this.rollback();
+                    reject(new Error('DbError: ' + message));
+                } else {
+                    trans.delete(this.ctx);
+                    const message = '事务提交成功！';
+                    this.$logger.sql(message);
+                    resolve(message);
+                }
+            });
+        });
+    }
+
+    /**
+     * 执行sql查询
+     * @public
+     * @param {string} sql - sql语句或参数
+     * @param {*} params - sql参数
+     * @returns {Promise}
+     */
+    async query(sql, params) {
+        params || (params = []);
+        const conn = await this._getConnect();
+
+        return new Promise((resolve, reject) => {
+            // 判断是SELECT查询还是其他操作
+            const isSelect = /^\s*select /i.test(sql);
+            const isTableInfo = /^\s*PRAGMA table_info/i.test(sql);
+
+            const that = this;
+            conn[isSelect || isTableInfo ? 'all' : 'run'](sql, params, function(err, rows) {
+                if(err) {
+                    const message = '数据操作失败，' + err.message + "\nSQL：" + that.format(sql, params);
+                    that.$logger.sql(message);
+                    that.$logger.error(message);
+                    reject(new Error('DbError: ' + message));
+                } else {
+                    that.$logger.sql('数据操作成功，SQL：' + that.format(sql, params));
+                    if(isSelect || isTableInfo) {
+                        resolve(rows);
+                    } else {
+                        resolve({
+                            affectedRows: this.changes,
+                            insertId: this.lastID
+                        });
+                    }
+                }
+                if(!trans.has(that.ctx)) {
+                    // SQLite不需要显式释放连接
+                }
+            });
+        });
+    }
+
+    /**
+     * 序列化sql语句
+     * @public
+     * @param {string} sql - sql语句或参数
+     * @param {*} params - sql参数
+     * @returns {string}
+     */
+    format(sql, params) {
+        params || (params = []);
+
+        let formatted = sql;
+        for(let i = 0; i < params.length; i++) {
+            let value = params[i];
+            if (typeof value === 'string') {
+                value = "'" + value.replace(/'/g, "''") + "'";
+            } else if (value === null) {
+                value = 'NULL';
+            }
+            formatted = formatted.replace(/\?/, value);
+        }
+        return formatted;
+    }
+
+    /**
+     * 获取数据表信息
+     * @public
+     * @param {string} tableName - 表名字
+     * @returns {Promise<FieldInfo[]>}
+     */
+    async tableInfo(tableName) {
+        const columns = await this.query(`PRAGMA table_info(${tableName})`);
+        return columns.map(col => {
+            return {
+                Field: col.name,
+                Type: col.type,
+                Null: col.notnull === 1 ? 'NO' : 'YES',
+                Key: col.pk === 1 ? 'PRI' : '',
+                Default: col.dflt_value,
+                Extra: col.pk === 1 ? 'auto_increment' : '',
+            };
+        });
+    }
+}
+
+module.exports = Sqlite;

package/lib/db.js

@@ -3,29 +3,16 @@ const md5 = require('./utils/md5');
 const Context = require('./context');
 
 /**
+ * @typedef {import('../types').KoaCtx} KoaCtx
  * @typedef {import('../types').Pagination} Pagination
  * @typedef {import('../types').PaginationInstance} PaginationInstance
- * @typedef {import('../types').Pool} Pool
- * @typedef {import('../types').PoolConfig} PoolConfig
- * @typedef {import('../types').PoolConnection} PoolConnection
- * @typedef {import('../types').QueryOptions} QueryOptions
  * @typedef {import('../types').OkPacket} OkPacket
  * @typedef {import('../types').RowData} RowData
  * @typedef {import('../types').ListData} ListData
  * @typedef {import('../types').FieldInfo} FieldInfo
- * @typedef {import('../types').PoolMap} PoolMap
+ * @typedef {import('../types').SqlInstance} SqlInstance
  */
 
-//连接池
-/**
- * @type {PoolMap}
- */
-const pool = new Map();
-//事务连接
-const trans = new Map();
-//事务嵌套
-const nest = new Map();
-
 /**
  * @extends Context
  */
@@ -34,8 +21,8 @@ class Db extends Context
     /**
      * Initialize a new `Db`
      * @public
-     * @param {import('../types').KoaCtx} [ctx]
-     * @param {(string|PoolConfig)} [options] - 数据库配置标识或连接参数
+     * @param {(object|KoaCtx)} [ctx]
+     * @param {(string|object)} [options] - 数据库配置标识或连接参数
      */
     constructor(ctx, options) {
         ctx = ctx || {};
@@ -48,6 +35,10 @@ class Db extends Context
          */
         this._queryStr = '';
         this._tableField = {};
+        /**
+         * @type {SqlInstance}
+         */
+        this._sql = null;
         this.connect(options);
     }
 
@@ -78,28 +69,20 @@ class Db extends Context
     /**
      * 连接数据库连接池
      * @public
-     * @param {(string|PoolConfig)} options - 数据库配置标识或连接参数
+     * @param {(string|object)} config - 数据库配置标识或连接参数
      * @returns {this}
      */
-    connect(options='default') {
-        this._config = typeof options === 'string' ? cfg_db[options] : options;
+    connect(config='default') {
+        this._config = typeof config === 'string' ? cfg_db[config] : config;
         this.reset();
 
-        /**
-         * @type {Pool}
-         */
-        let cur_pool = pool.get(this._config);
-        if(!cur_pool) {
-            switch(this._config.type) {
-                case 'mysql':
-                    cur_pool = require('mysql').createPool(this._config);
-                    break;
-                default:
-                    //other database, please provide database driver and implement the connection method
-                    cur_pool = this._config.connect(this._config);
-            }
-            pool.set(this._config, cur_pool);
-            this.$logger.sql(`连接池创建成功：{all: ${pool.size}}`);
+        if(this._config.connect) {
+            this._sql = this._config.connect(this._config);
+        } else {
+            const sqltype = this._config.type;
+            const Sql = require(`./db/${sqltype}.js`);
+            this._sql = new Sql(this.ctx, this.$logger);
+            this._sql.connect(this._config);
         }
         
         return this;
@@ -111,67 +94,7 @@ class Db extends Context
      * @returns {Promise}
      */
     async close() {
-        return new Promise((resolve, reject) => {
-            pool.has(this._config) && pool.get(this._config).end(err => {
-                if(err) {
-                    const message = '连接池销毁失败：' + err.message;
-                    this.$logger.sql(message);
-                    this.$logger.error(message);
-                    reject(new Error('DbError: ' + message));
-                } else {
-                    pool.delete(this._config);
-                    this.$logger.sql(`连接池销毁成功：{poolTotal: ${pool.size}}`);
-                    resolve(this);
-                }
-            });
-        });
-    }
-
-    /**
-     * 释放数据库连接
-     * @public
-     * @param {PoolConnection} conn - 数据库连接
-     */
-    release(conn) {
-        try {
-            conn.release();
-            this.$logger.sql('释放数据库连接！');
-        } catch(e) {
-            const message = '释放数据库出错：' + e.message;
-            this.$logger.sql(message);
-            this.$logger.error(message);
-        }
-    }
-
-    /**
-     * 获取数据库连接
-     * @private
-     * @param {Pool} p 
-     * @returns {Promise}
-     */
-    async _creatConnect(p) {
-        return new Promise((resolve, reject) => {
-            p.getConnection((err, connection) => {
-                if(err) {
-                    const message = '获取数据库连接失败：' + err.message;
-                    this.$logger.sql(message);
-                    this.$logger.error(message);
-                    reject(new Error('DbError: ' + message));
-                } else {
-                    this.$logger.sql(`获取数据库连接：{limit: ${p.config.connectionLimit}, all: ${p._allConnections.length}, acquiring: ${p._acquiringConnections.length}, free: ${p._freeConnections.length}, queue: ${p._connectionQueue.length}}`);
-                    resolve(connection);
-                }
-            });
-        });
-    }
-
-    /**
-     * 获取数据库连接
-     * @private
-     * @returns {Promise<PoolConnection>}
-     */
-    async _getConnect() {
-        return trans.get(this.ctx) || await this._creatConnect(pool.get(this._config));
+        return await this._sql.close();
     }
 
     /**
@@ -181,49 +104,7 @@ class Db extends Context
      * @returns {Promise<string>}
      */
     async startTrans(fun) {
-        const conn = await this._getConnect();
-        trans.set(this.ctx, conn);
-        let trans_nest = nest.get(conn) || 0;
-        nest.set(conn, ++trans_nest);
-        if(trans_nest > 1) {
-            const message = `开启事务成功：{nest:${trans_nest}}`;
-            this.$logger.sql(message);
-            if(typeof fun === 'function') {
-                try {
-                    await fun();
-                    await this.commit();
-                } catch(e) {
-                    await this.rollback();
-                    throw e;
-                }
-            }
-            return message;
-        }
-
-        return new Promise((resolve, reject) => {
-            conn.beginTransaction(async (err) => {
-                if(err) {
-                    const message = '开启事务失败：' + err.message;
-                    this.$logger.sql(message);
-                    this.$logger.error(message);
-                    reject(new Error('DbError: ' + message));
-                } else {
-                    const message = '开启事务成功！';
-                    this.$logger.sql(message);
-                    if(typeof fun === 'function') {
-                        try {
-                            await fun();
-                            await this.commit();
-                            resolve('事务执行成功！');
-                        } catch(e) {
-                            await this.rollback();
-                            reject(e);
-                        }
-                    }
-                    resolve(message);
-                }
-            });
-        });
+        return await this._sql.startTrans(fun);
     }
 
     /**
@@ -232,26 +113,7 @@ class Db extends Context
      * @returns {Promise<string>}
      */
     async rollback() {
-        const conn = await this._getConnect();
-        const trans_nest = nest.get(conn) || 0;
-        if(trans_nest > 1) {
-            nest.set(conn, trans_nest - 1);
-            const message = `事务回滚成功：{nest:${trans_nest}}`;
-            this.$logger.sql(message);
-            return message;
-        } else {
-            nest.delete(conn);
-        }
-
-        return new Promise((resolve) => {
-            conn.rollback(() => {
-                trans.delete(this.ctx);
-                const message = '事务回滚成功！';
-                this.$logger.sql(message);
-                this.release(conn);
-                resolve(message);
-            });
-        });
+        return await this._sql.rollback();
     }
 
     /**
@@ -260,34 +122,7 @@ class Db extends Context
      * @returns {Promise<string>}
      */
     async commit() {
-        const conn = await this._getConnect();
-        const trans_nest = nest.get(conn) || 0;
-        if(trans_nest > 1) {
-            nest.set(conn, trans_nest - 1);
-            const message = `事务提交成功：{nest:${trans_nest}}`;
-            this.$logger.sql(message);
-            return message;
-        } else {
-            nest.delete(conn);
-        }
-
-        return new Promise((resolve, reject) => {
-            conn.commit((err) => {
-                if(err) {
-                    const message = '事务提交失败：' + err.message;
-                    this.$logger.sql(message);
-                    this.$logger.error(message);
-                    this.rollback();
-                    reject(new Error('DbError: ' + message));
-                } else {
-                    trans.delete(this.ctx);
-                    const message = '事务提交成功！';
-                    this.$logger.sql(message);
-                    this.release(conn);
-                    resolve(message);
-                }
-            });
-        });
+        return await this._sql.commit();
     }
 
     /**
@@ -302,27 +137,7 @@ class Db extends Context
         params !== false && reset !== false && this.reset();
         params || (params = []);
         
-        /**
-         * @type {PoolConnection}
-         */
-        const conn = await this._getConnect();
-
-        return new Promise((resolve, reject) => {
-            conn.query(sql, params, (err, data) => {
-                if(err) {
-                    const message = '数据操作失败，' + err.message + "\r\nSQL：" + this.format(sql, params);
-                    this.$logger.sql(message);
-                    this.$logger.error(message);
-                    reject(new Error('DbError: ' + message));
-                } else {
-                    this.$logger.sql('数据操作成功，SQL：' + this.format(sql, params));
-                    resolve(data);
-                }
-                if(!trans.has(this.ctx)) {
-                    this.release(conn);
-                }
-            });
-        });
+        return await this._sql.query(sql, params);
     }
 
     /**
@@ -531,7 +346,7 @@ class Db extends Context
      * 获取多条数据
      * @public
      * @param {object} condition - 查询条件
-     * @returns {Promise<ListData>}
+     * @returns {Promise<string|ListData>}
      */
     async select(condition) {
         condition && (this._options.where = [], this._options.where.push([condition]));
@@ -555,12 +370,12 @@ class Db extends Context
 
         if(this._options.getSql) {
             this._options.getSql = false;
-            return this.format(this._queryStr, params);
+            return this._sql.format(this._queryStr, params);
         }
         
         if(this._options.cache_time) {
             const cache_time = this._options.cache_time;
-            const cache_key = md5(this.format(this._queryStr, params));
+            const cache_key = md5(this._sql.format(this._queryStr, params));
             if(this.getCache(cache_key)) {
                 this.reset();
                 return this.getCache(cache_key);
@@ -675,6 +490,9 @@ class Db extends Context
             return await this.select();
         }
 
+        /**
+         * @type {ListData}
+         */
         const rows = await this.select();
         const result = key ? {} : [];
         rows.forEach(row => {
@@ -723,23 +541,19 @@ class Db extends Context
      * 插入一条数据
      * @public
      * @param {object} data - 待插入数据
-     * @returns {Promise<OkPacket>}
+     * @returns {Promise<string|OkPacket>}
      */
     async insert(data) {
         data && (this._options.data = data);
 
-        let params = [];
         const table = this._parseTable();
-
         await this._filterData();
+        const [sql, params] = this._parseInsertData();
 
-        data = this._parseData();
-        params = params.concat(data[1]);
-
-        this._queryStr = `insert into ${table} set ${data[0]}`;
+        this._queryStr = `insert into ${table} ${sql}`;
         if(this._options.getSql) {
             this._options.getSql = false;
-            return this.format(this._queryStr, params);
+            return this._sql.format(this._queryStr, params);
         }
         return await this.query(this._queryStr, params);
     }
@@ -749,32 +563,28 @@ class Db extends Context
      * @public
      * @param {object} data - 更新数据
      * @param {object} condition - 更新条件
-     * @returns {Promise<OkPacket>}
+     * @returns {Promise<string|OkPacket>}
      */
     async update(data, condition) {
         data && (this._options.data = data);
         condition && (this._options.where = [], this._options.where.push([condition]));
 
-        let params = [];
         const table = this._parseTable();
-
         await this._filterData();
+        const [sql, dataParams] = this._parseUpdateData();
 
-        data = this._parseData();
-        params = params.concat(data[1]);
-
-        const where = this._parseWhere();
+        const [where, whereParams] = this._parseWhere();
         if(!where[0]) {
             const message = 'update方法必须传入where参数';
             this.$logger.sql(message);
             throw new Error('DbError: ' + message);
         }
-        params = params.concat(where[1]);
+        const params = [...dataParams, ...whereParams];
 
-        this._queryStr = `update ${table} set ${data[0]} ${where[0]}`;
+        this._queryStr = `update ${table} set ${sql} ${where}`;
         if(this._options.getSql) {
             this._options.getSql = false;
-            return this.format(this._queryStr, params);
+            return this._sql.format(this._queryStr, params);
         }
         return await this.query(this._queryStr, params);
     }
@@ -784,7 +594,7 @@ class Db extends Context
      * @public
      * @param {string} field - 字段
      * @param {number} [step=1] - 增加值，默认1
-     * @returns {Promise<OkPacket>}
+     * @returns {Promise<string|OkPacket>}
      */
     async inc(field, step) {
         return await this.update({[field]: ['inc', step]});
@@ -795,7 +605,7 @@ class Db extends Context
      * @public
      * @param {string} field - 字段
      * @param {number} [step=1] - 减少值，默认1
-     * @returns {Promise<OkPacket>}
+     * @returns {Promise<string|OkPacket>}
      */
     async dec(field, step) {
         return await this.update({[field]: ['dec', step]});
@@ -806,7 +616,7 @@ class Db extends Context
      * @public
      * @param {string} field - 字段
      * @param {string} value - 自定义表达式
-     * @returns {Promise<OkPacket>}
+     * @returns {Promise<string|OkPacket>}
      */
     async exp(field, value) {
         return await this.update({[field]: ['exp', value]});
@@ -815,8 +625,8 @@ class Db extends Context
     /**
      * 删除数据
      * @public
-     * @param {object} condition - 山粗条件
-     * @returns {Promise<OkPacket>}
+     * @param {object} condition - 删除条件
+     * @returns {Promise<string|OkPacket>}
      */
     async delete(condition) {
         condition && (this._options.where = [], this._options.where.push([condition]));
@@ -834,7 +644,7 @@ class Db extends Context
         this._queryStr = `delete from ${table} ${where[0]}`;
         if(this._options.getSql) {
             this._options.getSql = false;
-            return this.format(this._queryStr, params);
+            return this._sql.format(this._queryStr, params);
         }
         return await this.query(this._queryStr, params);
     }
@@ -845,18 +655,18 @@ class Db extends Context
      * @param {string} sql - sql语句或参数
      * @param {*} params - sql参数
      * @param {*} [reset=true] - 是否重置参数
-     * @returns {Promise<(OkPacket|ListData|RowData)>}
+     * @returns {Promise<string|OkPacket|ListData|RowData>}
      */
     async execute(sql, params, reset=true) {
         this._queryStr = sql;
         if(this._options.getSql) {
             this._options.getSql = false;
-            return this.format(this._queryStr, params);
+            return this._sql.format(this._queryStr, params);
         }
 
         if(this._options.cache_time) {
             const cache_time = this._options.cache_time;
-            const cache_key = md5(this.format(this._queryStr, params));
+            const cache_key = md5(this._sql.format(this._queryStr, params));
             if(this.getCache(cache_key)) {
                 return this.getCache(cache_key);
             }
@@ -876,7 +686,7 @@ class Db extends Context
     async tableInfo(table) {
         const get_sql = this._options.getSql;
         this._options.getSql = false;
-        const table_info = await this.table(table).execute(`show columns from ${this._parseTable()}`, false);
+        const table_info = await this.table(table)._sql.tableInfo(this._parseTable());
         this._options.getSql = get_sql;
         return table_info;
     }
@@ -892,18 +702,6 @@ class Db extends Context
         return table_info.map(item => item.Field);
     }
 
-    /**
-     * 序列化sql语句
-     * @public
-     * @param {string} sql - sql语句或参数
-     * @param {*} params - sql参数
-     * @returns {string}
-     */
-    format(sql, params) {
-        params || (params = []);
-        return require('mysql').format(sql, params);
-    }
-
     _parseTable() {
         const table = this._table.replace(' ', '` `');
         return `\`${this._options.prefix}${table}\``;
@@ -1004,7 +802,21 @@ class Db extends Context
         return order;
     }
 
-    _parseData() {
+    _parseInsertData() {
+        const fields = [];
+        const values = [];
+        const params = [];
+        Object.keys(this._options.data).forEach(key => {
+            const field = '`' + key.replace('.', '`.`') + '`';
+            fields.push(field);
+            values.push('?');
+            const value = this._options.data[key];
+            params.push(value);
+        });
+        return [`(${fields.join(', ')}) values (${values.join(', ')})`, params];
+    }
+
+    _parseUpdateData() {
         let data = '';
         const params = [];
         Object.keys(this._options.data).forEach(key => {

package/lib/request.js

@@ -61,6 +61,9 @@ class Request extends Context
      * @returns {*}
      */
     post(key, default_value='') {
+        if(!this.$config.app.koa_body && key !== 'is_ajax') {
+            this.$logger.error('请先在app配置中开启koa_body');
+        }
         return this._post[key] || default_value;
     }
 

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "jj.js",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "A super simple lightweight NodeJS MVC framework（一个超级简单轻量的NodeJS MVC框架）",
   "main": "jj.js",
-  "scripts": {},
+  "scripts": {
+    "test": "node ./test/server.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/yafoo/jj.js.git"
@@ -28,6 +30,7 @@
     "koa-body": "^6.0.1",
     "koa-static": "^5.0.0",
     "mysql": "^2.18.1",
+    "sqlite3": "^5.1.7",
     "watch": "^1.0.2"
   },
   "engines": {

package/types.js

@@ -210,7 +210,10 @@
  * @property {string} Key
  * @property {string} Default
  * @property {string} Extra
- * @typedef {Map<Pool>} PoolMap
+ */
+
+/**
+ * @typedef {import('./lib/db/sql').prototype} SqlInstance - Sql实例
  */