doomiwork 3.4.1 → 3.5.1

package/core/database/mysqlbase.js

@@ -6,6 +6,7 @@ const apiResult = require('../actionresult');
 const logHelper = require('doomi-helper').logHelper;
 const PoolManager = require('./poolmanager')
 const mysql = require('mysql');
+const executeSqlWithConnection = Symbol("executeSqlWithConnection");
 class Database {
     /**
      * 
@@ -21,29 +22,31 @@ class Database {
      * 防Sql注入进行编码
      * @param {*} value 
      */
-    escape(value){
+    escape(value) {
         return mysql.escape(value);
     }
     /**
      * 记录错误日志
      */
-    logError(scene,error,user=null){
+    logError(scene, error, user = null) {
         ///不需要记录错误日志
-        if (this.ingoreErrorLog === true || !this.actionLogger || typeof (this.actionLogger.logError)!=='function'){
-            return ;
+        if (this.ingoreErrorLog === true || !this.actionLogger || typeof (this.actionLogger.logError) !== 'function') {
+            return;
         }
         ///如果没有传场景，则记录数据库的业务值
         if (!scene) scene = this.constructor.name;
-        this.actionLogger.logError({ scene, error, user})
+        this.actionLogger.logError({ scene, error, user })
     }
     /**
      * 检查是否存在数据
      * @param {*} sqlCommand 
      * @param {*} parameters 
      */
-    async existedSqlData(sqlCommand, parameters){
-        let sqlExecute = await this.executeSql(sqlCommand, parameters);
-        return { successed: sqlExecute.successed, existed: sqlExecute.rows.length>=1}
+    async existedSqlData(sqlCommand, parameters, conn, autoclose = true) {
+        let sqlExecute = await this.executeSql(sqlCommand, parameters, conn, autoclose);
+        if (!sqlExecute.successed) return { successed: false }
+        if (!sqlExecute.rows || sqlExecute.rows.length == 0) return { success: true, existed: false }
+        return { successed: true, existed: true, ...sqlExecute.rows[0] }
     }
     /**
      * 获取到第一行记录的所有字段的值
@@ -51,87 +54,107 @@ class Database {
      * @param {*} parameters 
      * @returns 
      */
-    async getComputedRowValue(sqlCommand, parameters) {
-        let sqlExecute = await this.executeSql(sqlCommand, parameters);
-        if (sqlExecute.successed || sqlExecute.rows===0) return {successed:false,errcode:-1,errmsg:'没有任何记录'}
+    async getComputedRowValue(sqlCommand, parameters, conn, autoclose = true) {
+        let sqlExecute = await this.executeSql(sqlCommand, parameters, conn, autoclose);
+        if (sqlExecute.successed || sqlExecute.rows === 0) return { successed: false, errcode: -1, errmsg: '没有任何记录' }
         return { successed: true, ...sqlExecute.rows[0] }
     }
+
+    /**
+     * 单独获得一个连接串
+     * @returns 
+     */
+    getConnection() {
+        return new Promise((success, failed) => {
+            if (!this.pool) {
+                return success(null);
+            }
+            this.pool.getConnection(function (err, connection) {
+                if (err) return success(null);;
+                return success(connection)
+            });
+        });
+    }
     /**
      * 不事务执行SQL命令
      * @param {*} sqlCommand 
      * @param {*} parameters  参数
      */
-    executeSql(sqlCommand, parameters) {
+    executeSql(sqlCommand, parameters, conn, autoclose = true) {
         let logger = this.logger;
-        let that = this;
+        // let that = this;
+        if (conn) {
+            return this[executeSqlWithConnection](sqlCommand, parameters, conn, autoclose)
+        }
         return new Promise((success, failed) => {
             if (!this.pool) {
                 return success(apiResult.DB_CONNECTED_FAILED);
             }
             ///创建出数据库连接，准备执行
-            this.pool.getConnection(function (err, connection) {
+            this.pool.getConnection(async (err, connection) => {
                 if (err) {
-                    logger.error("Database Connected Failed :"+ err);
+                    logger.error("Database Connected Failed :" + err);
                     return success(apiResult.DB_CONNECTED_FAILED);
                 }
-                else {
-                    logger.trace("SqlCommand:", sqlCommand, "Parameters:", parameters);
-                    connection.query(sqlCommand, parameters, function (err, rows) {
-                        connection.release();
-                        if (err) {
-                            logger.error("Database Query Error :" + err, sqlCommand);
-                            that.logError(null, '数据库操作错误:' + err + sqlCommand)
-                            return success(Object.assign(apiResult.DB_EXECUTE_FAILED, { errmessage: err.message }));
-                        }
-                        return success({ successed: true, rows: rows });//,fields:fields});
-                    });
-                }
+                let sqlResult = await this[executeSqlWithConnection](sqlCommand, parameters, connection, autoclose)
+                return success(sqlResult)
             });
         });
     }
-
     /**
-     * 带事务执行SQL命令
+     * 使用一个已存在的链接Query Sql
      * @param {*} sqlCommand 
-     * @param {*} parameters  参数
+     * @param {*} parameters 
+     * @param {*} conn 
+     * @param {*} closeAfterQuery 执行完毕后是否关闭
      */
-    executeSqlWithTransaction(sqlCommand, parameters) {
-        let logger = this.logger;
-        return new Promise((success, failed) => {
-            if (!this.pool) return success(apiResult.DB_CONNECTED_FAILED);
-            ///创建出数据库连接，准备执行
-            this.pool.getConnection(function (err, connection) {
+    [executeSqlWithConnection](sqlCommand, parameters, conn, autoclose = true) {
+        if (!conn) return Promise.resolve(apiResult.DB_CONNECTED_FAILED);
+        return new Promise((success) => {
+            this.logger.trace("SqlCommand:", sqlCommand, "Parameters:", parameters);
+            return conn.query(sqlCommand, parameters, (err, rows) => {
+                if (autoclose) conn.release();
                 if (err) {
-                    logger.error("Database Connected Failed :"+ err);
-                    return success(apiResult.DB_CONNECTED_FAILED);
+                    this.logger.error("Database Query Error :" + err, sqlCommand);
+                    this.logError(null, '数据库操作错误:' + err + sqlCommand)
+                    return success(Object.assign(apiResult.DB_EXECUTE_FAILED, { errmessage: err.message }));
                 }
-                logger.trace("SqlCommand:", sqlCommand, "Parameters:", parameters);
-                ////开启事务保护
-                connection.beginTransaction(transerr=>{
-                    if (transerr) return success(Object.assign(apiResult.DB_EXECUTE_FAILED, { errmessage: transerr.message })); 
-                    connection.query(sqlCommand, parameters, function (err, rows) {
-                        ////执行出错，事务回滚
-                        if (err) {
-                            logger.error("Database Query Error :"+ err);
-                            return connection.rollback(() => {
-                                connection.release();
-                                return success(Object.assign(apiResult.DB_EXECUTE_FAILED, { errmessage: err.message }));
-                            })
-                        }
-                        ///执行成功，事务提交
-                        connection.commit(commiterror => {
-                            if(commiterror) {
-                                logger.error('事务提交失败 :',commiterror);
-                                return success(Object.assign(apiResult.DB_EXECUTE_FAILED, { errmessage: err.message }));
-                            }
-                            connection.release();
-                            return success({ successed: true, rows: rows });
-                        })
-                    });
-                })
-                
+                return success({ successed: true, rows: rows });//,fields:fields});
             });
-        });
+        })
+    }
+    /**
+     * 启动事务进行保护性操作
+     * @param {*} conn 
+     * @param {*} func 
+     */
+    async executeSqlWithTransaction(conn, func) {
+        if (!conn) {
+            conn = await this.getConnection();
+        }
+        if (!conn) return Promise.resolve({ successed: false });
+        return new Promise(success => {
+            conn.beginTransaction(async err => {
+                if (err) return success({ successed: false, errcode: -1, errmessage: '【事务启动错误】' + err.message });
+                let result = { successed: true }
+                if (func && typeof (func) === 'function') result = await func(conn);
+                if (result.successed) {
+                    conn.commit(commiterror => {
+                        if (commiterror) {
+                            console.log('事务提交失败 :', commiterror);
+                            return success(Object.assign(apiResult.DB_EXECUTE_FAILED, { errmessage: commiterror.message }));
+                        }
+                        conn.release();
+                        return success(result);
+                    })
+                } else {
+                    conn.rollback(() => {
+                        conn.release();
+                        return success(Object.assign(apiResult.DB_EXECUTE_FAILED, { errmessage: '撤回操作' }));
+                    })
+                }
+            })
+        })
     }
 }
 module.exports = Database;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doomiwork",
-  "version": "3.4.1",
+  "version": "3.5.1",
   "description": "doomisoft nodejs web framework",
   "main": "index.js",
   "scripts": {