mysql2-core 0.2.4 → 0.3.1

package/lib/index.js

@@ -67,28 +67,101 @@ function createPool(conf) {
   return pool;
 }
 exports.createPool = createPool;
+function getConnection(pool) {
+  return new Promise(function (resolve, reject) {
+    pool.getConnection(function (err, connection) {
+      if (err) {
+        return reject(err);
+      }
+      return resolve(connection);
+    });
+  });
+}
+exports.getConnection = getConnection;
+function beginTransaction(connection, rollbackIfError) {
+  return new Promise(function (resolve, reject) {
+    connection.beginTransaction(function (err) {
+      if (err) {
+        if (!rollbackIfError) {
+          return reject(err);
+        }
+        connection.rollback(function () {
+          return reject(err);
+        });
+      }
+      return resolve();
+    });
+  });
+}
+exports.beginTransaction = beginTransaction;
+function commit(connection, rollbackIfError) {
+  return new Promise(function (resolve, reject) {
+    connection.commit(function (err) {
+      if (err) {
+        if (!rollbackIfError) {
+          return reject(err);
+        }
+        connection.rollback(function () {
+          return reject(err);
+        });
+      }
+      resolve();
+    });
+  });
+}
+exports.commit = commit;
+function rollback(connection) {
+  return new Promise(function (resolve, reject) {
+    connection.rollback(function (err) {
+      if (err) {
+        return reject(err);
+      }
+      resolve();
+    });
+  });
+}
+exports.rollback = rollback;
 var PoolManager = (function () {
   function PoolManager(pool) {
     this.pool = pool;
     this.driver = "mysql";
     this.param = this.param.bind(this);
-    this.exec = this.exec.bind(this);
-    this.execBatch = this.execBatch.bind(this);
+    this.execute = this.execute.bind(this);
+    this.executeBatch = this.executeBatch.bind(this);
     this.query = this.query.bind(this);
     this.queryOne = this.queryOne.bind(this);
-    this.execScalar = this.execScalar.bind(this);
+    this.executeScalar = this.executeScalar.bind(this);
     this.count = this.count.bind(this);
   }
   PoolManager.prototype.param = function (i) {
     return "?";
   };
-  PoolManager.prototype.exec = function (sql, args, ctx) {
+  PoolManager.prototype.beginTransaction = function () {
+    var _this = this;
+    return new Promise(function (resolve, reject) {
+      _this.pool.getConnection(function (er0, connection) {
+        if (er0) {
+          return reject(er0);
+        }
+        connection.beginTransaction(function (er1) {
+          if (er1) {
+            connection.rollback(function () {
+              return reject(er1);
+            });
+          }
+          var tx = new PoolConnectionManager(connection);
+          return resolve(tx);
+        });
+      });
+    });
+  };
+  PoolManager.prototype.execute = function (sql, args, ctx) {
     var p = ctx ? ctx : this.pool;
-    return exec(p, sql, args);
+    return execute(p, sql, args);
   };
-  PoolManager.prototype.execBatch = function (statements, firstSuccess, ctx) {
+  PoolManager.prototype.executeBatch = function (statements, firstSuccess, ctx) {
     var p = ctx ? ctx : this.pool;
-    return execBatch(p, statements, firstSuccess);
+    return executeBatch(p, statements, firstSuccess);
   };
   PoolManager.prototype.query = function (sql, args, m, bools, ctx) {
     var p = ctx ? ctx : this.pool;
@@ -98,9 +171,9 @@ var PoolManager = (function () {
     var p = ctx ? ctx : this.pool;
     return queryOne(p, sql, args, m, bools);
   };
-  PoolManager.prototype.execScalar = function (sql, args, ctx) {
+  PoolManager.prototype.executeScalar = function (sql, args, ctx) {
     var p = ctx ? ctx : this.pool;
-    return execScalar(p, sql, args);
+    return executeScalar(p, sql, args);
   };
   PoolManager.prototype.count = function (sql, args, ctx) {
     var p = ctx ? ctx : this.pool;
@@ -109,135 +182,593 @@ var PoolManager = (function () {
   return PoolManager;
 }());
 exports.PoolManager = PoolManager;
-function execBatch(pool, statements, firstSuccess) {
-  if (!statements || statements.length === 0) {
-    return Promise.resolve(0);
-  }
-  else if (statements.length === 1) {
-    return exec(pool, statements[0].query, statements[0].params);
+var PoolConnectionManager = (function () {
+  function PoolConnectionManager(connection) {
+    this.connection = connection;
+    this.driver = "mysql";
+    this.param = this.param.bind(this);
+    this.execute = this.execute.bind(this);
+    this.executeBatch = this.executeBatch.bind(this);
+    this.query = this.query.bind(this);
+    this.queryOne = this.queryOne.bind(this);
+    this.executeScalar = this.executeScalar.bind(this);
+    this.count = this.count.bind(this);
   }
-  if (firstSuccess) {
+  PoolConnectionManager.prototype.param = function (i) {
+    return "?";
+  };
+  PoolConnectionManager.prototype.commit = function () {
+    var _this = this;
     return new Promise(function (resolve, reject) {
-      pool.getConnection(function (er0, connection) {
-        if (er0) {
-          return reject(er0);
+      _this.connection.commit(function (er3) {
+        if (er3) {
+          return reject(er3);
         }
-        connection.beginTransaction(function (er1) {
-          if (er1) {
-            connection.rollback(function () {
-              return reject(er1);
-            });
+        return resolve();
+      });
+    });
+  };
+  PoolConnectionManager.prototype.rollback = function () {
+    var _this = this;
+    return new Promise(function (resolve, reject) {
+      _this.connection.rollback(function (er3) {
+        if (er3) {
+          return reject(er3);
+        }
+        return resolve();
+      });
+    });
+  };
+  PoolConnectionManager.prototype.execute = function (sql, args, ctx) {
+    var p = ctx ? ctx : this.connection;
+    return execute(p, sql, args);
+  };
+  PoolConnectionManager.prototype.executeBatch = function (statements, firstSuccess, ctx) {
+    var p = ctx ? ctx : this.connection;
+    return executeBatchConnection(p, statements, firstSuccess);
+  };
+  PoolConnectionManager.prototype.query = function (sql, args, m, bools, ctx) {
+    var p = ctx ? ctx : this.connection;
+    return query(p, sql, args, m, bools);
+  };
+  PoolConnectionManager.prototype.queryOne = function (sql, args, m, bools, ctx) {
+    var p = ctx ? ctx : this.connection;
+    return queryOne(p, sql, args, m, bools);
+  };
+  PoolConnectionManager.prototype.executeScalar = function (sql, args, ctx) {
+    var p = ctx ? ctx : this.connection;
+    return executeScalar(p, sql, args);
+  };
+  PoolConnectionManager.prototype.count = function (sql, args, ctx) {
+    var p = ctx ? ctx : this.connection;
+    return count(p, sql, args);
+  };
+  return PoolConnectionManager;
+}());
+exports.PoolConnectionManager = PoolConnectionManager;
+function executeBatch(pool, statements, firstSuccess) {
+  return __awaiter(this, void 0, void 0, function () {
+    var connection;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          if (!statements || statements.length === 0) {
+            return [2, Promise.resolve(0)];
           }
-          else {
-            var query0 = "";
-            var queries_1 = [];
-            var l = statements.length;
-            for (var j = 0; j < l; j++) {
-              var item = statements[j];
-              if (j === 0) {
-                query0 = mysql2_1.format(item.query, toArray(item.params));
-              }
-              else {
-                if (item.query.endsWith(";")) {
-                  queries_1.push(mysql2_1.format(item.query, toArray(item.params)));
-                }
-                else {
-                  queries_1.push(mysql2_1.format(item.query + ";", toArray(item.params)));
-                }
-              }
-            }
-            connection.execute(query0, function (er2a, results0) {
-              if (er2a) {
-                connection.rollback(function () {
-                  return reject(er2a);
+          else if (statements.length === 1) {
+            return [2, execute(pool, statements[0].query, statements[0].params)];
+          }
+          if (!resource.multipleStatements) return [3, 1];
+          if (firstSuccess) {
+            return [2, new Promise(function (resolve, reject) {
+                pool.getConnection(function (er0, connection) {
+                  if (er0) {
+                    return reject(er0);
+                  }
+                  connection.beginTransaction(function (er1) {
+                    if (er1) {
+                      connection.rollback(function () {
+                        return reject(er1);
+                      });
+                    }
+                    else {
+                      connection.execute(statements[0].query, toArray(statements[0].params), function (er2a, results0) {
+                        if (er2a) {
+                          connection.rollback(function () {
+                            return reject(er2a);
+                          });
+                        }
+                        else {
+                          if (results0 && results0.affectedRows === 0) {
+                            connection.commit(function (er3) {
+                              if (er3) {
+                                connection.rollback(function () {
+                                  return reject(er3);
+                                });
+                              }
+                            });
+                            return 0;
+                          }
+                          else {
+                            var queries = [];
+                            var params = [];
+                            var l = statements.length;
+                            for (var j = 1; j < l; j++) {
+                              var item = statements[j];
+                              if (item.query.endsWith(";")) {
+                                queries.push(item.query);
+                              }
+                              else {
+                                queries.push(item.query + ";");
+                              }
+                              if (item.params && item.params.length > 0) {
+                                for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
+                                  var p = _a[_i];
+                                  params.push(p);
+                                }
+                              }
+                            }
+                            connection.query(queries.join(""), toArray(params), function (er2, results) {
+                              if (er2) {
+                                connection.rollback(function () {
+                                  return reject(er2);
+                                });
+                              }
+                              else {
+                                connection.commit(function (er3) {
+                                  if (er3) {
+                                    connection.rollback(function () {
+                                      return reject(er3);
+                                    });
+                                  }
+                                });
+                                var c = 0;
+                                c += results0.affectedRows + results.affectedRows;
+                                return resolve(c);
+                              }
+                            });
+                          }
+                        }
+                      });
+                    }
+                  });
                 });
-              }
-              else {
-                if (results0 && results0.affectedRows === 0) {
-                  return 0;
-                }
-                else {
-                  connection.execute(queries_1.join(""), function (er2, results) {
-                    if (er2) {
+              })];
+          }
+          else {
+            return [2, new Promise(function (resolve, reject) {
+                pool.getConnection(function (er0, connection) {
+                  if (er0) {
+                    return reject(er0);
+                  }
+                  connection.beginTransaction(function (er1) {
+                    if (er1) {
                       connection.rollback(function () {
-                        return reject(er2);
+                        return reject(er1);
                       });
                     }
                     else {
-                      connection.commit(function (er3) {
-                        if (er3) {
+                      var queries_1 = [];
+                      var params_1 = [];
+                      statements.forEach(function (item) {
+                        if (item.query.endsWith(";")) {
+                          queries_1.push(item.query);
+                        }
+                        else {
+                          queries_1.push(item.query + ";");
+                        }
+                        if (item.params && item.params.length > 0) {
+                          for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
+                            var p = _a[_i];
+                            params_1.push(p);
+                          }
+                        }
+                      });
+                      connection.query(queries_1.join(""), toArray(params_1), function (er2, results) {
+                        if (er2) {
                           connection.rollback(function () {
-                            return reject(er3);
+                            buildError(er2);
+                            return reject(er2);
                           });
                         }
+                        else {
+                          connection.commit(function (er3) {
+                            if (er3) {
+                              connection.rollback(function () {
+                                return reject(er3);
+                              });
+                            }
+                          });
+                          return resolve(results.affectedRows);
+                        }
                       });
-                      var c = 0;
-                      c += results0.affectedRows + results.affectedRows;
-                      return resolve(c);
                     }
                   });
-                }
-              }
-            });
+                });
+              })];
           }
-        });
-      });
+          return [3, 3];
+        case 1: return [4, getConnection(pool)];
+        case 2:
+          connection = _a.sent();
+          return [2, executeBatchConnectionTx(connection, statements, firstSuccess)];
+        case 3: return [2];
+      }
     });
-  }
-  else {
-    return new Promise(function (resolve, reject) {
-      pool.getConnection(function (er0, connection) {
-        if (er0) {
-          return reject(er0);
-        }
-        connection.beginTransaction(function (er1) {
-          if (er1) {
-            connection.rollback(function () {
-              return reject(er1);
-            });
+  });
+}
+exports.executeBatch = executeBatch;
+function executeBatchConnectionTx(connection, statements, firstSuccess) {
+  return __awaiter(this, void 0, void 0, function () {
+    var count_1, l, j, item, c, err_1, count_2, l, j, item, c, err_2;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          if (!statements || statements.length === 0) {
+            return [2, Promise.resolve(0)];
+          }
+          else if (statements.length === 1) {
+            return [2, execute(connection, statements[0].query, statements[0].params)];
+          }
+          if (!resource.multipleStatements) return [3, 1];
+          if (firstSuccess) {
+            return [2, new Promise(function (resolve, reject) {
+                connection.beginTransaction(function (er1) {
+                  if (er1) {
+                    connection.rollback(function () {
+                      return reject(er1);
+                    });
+                  }
+                  else {
+                    connection.execute(statements[0].query, toArray(statements[0].params), function (er2a, results0) {
+                      if (er2a) {
+                        connection.rollback(function () {
+                          return reject(er2a);
+                        });
+                      }
+                      else {
+                        if (results0 && results0.affectedRows === 0) {
+                          connection.commit(function (er3) {
+                            if (er3) {
+                              connection.rollback(function () {
+                                return reject(er3);
+                              });
+                            }
+                          });
+                          return 0;
+                        }
+                        else {
+                          var queries = [];
+                          var params = [];
+                          var l = statements.length;
+                          for (var j = 1; j < l; j++) {
+                            var item = statements[j];
+                            if (item.query.endsWith(";")) {
+                              queries.push(item.query);
+                            }
+                            else {
+                              queries.push(item.query + ";");
+                            }
+                            if (item.params && item.params.length > 0) {
+                              for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
+                                var p = _a[_i];
+                                params.push(p);
+                              }
+                            }
+                          }
+                          connection.query(queries.join(""), toArray(params), function (er2, results) {
+                            if (er2) {
+                              connection.rollback(function () {
+                                return reject(er2);
+                              });
+                            }
+                            else {
+                              connection.commit(function (er3) {
+                                if (er3) {
+                                  connection.rollback(function () {
+                                    return reject(er3);
+                                  });
+                                }
+                              });
+                              var c = 0;
+                              c += results0.affectedRows + results.affectedRows;
+                              return resolve(c);
+                            }
+                          });
+                        }
+                      }
+                    });
+                  }
+                });
+              })];
           }
           else {
-            var queries_2 = [];
-            statements.forEach(function (item) {
-              if (item.query.endsWith(";")) {
-                queries_2.push(mysql2_1.format(item.query, toArray(item.params)));
-              }
-              else {
-                queries_2.push(mysql2_1.format(item.query + ";", toArray(item.params)));
-              }
-            });
-            connection.execute(queries_2.join(""), function (er2, results) {
-              if (er2) {
-                connection.rollback(function () {
-                  buildError(er2);
-                  return reject(er2);
+            return [2, new Promise(function (resolve, reject) {
+                connection.beginTransaction(function (er1) {
+                  if (er1) {
+                    connection.rollback(function () {
+                      return reject(er1);
+                    });
+                  }
+                  else {
+                    var queries_2 = [];
+                    var params_2 = [];
+                    statements.forEach(function (item) {
+                      if (item.query.endsWith(";")) {
+                        queries_2.push(item.query);
+                      }
+                      else {
+                        queries_2.push(item.query + ";");
+                      }
+                      if (item.params && item.params.length > 0) {
+                        for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
+                          var p = _a[_i];
+                          params_2.push(p);
+                        }
+                      }
+                    });
+                    connection.query(queries_2.join(""), toArray(params_2), function (er2, results) {
+                      if (er2) {
+                        connection.rollback(function () {
+                          buildError(er2);
+                          return reject(er2);
+                        });
+                      }
+                      else {
+                        connection.commit(function (er3) {
+                          if (er3) {
+                            connection.rollback(function () {
+                              return reject(er3);
+                            });
+                          }
+                        });
+                        return resolve(results.affectedRows);
+                      }
+                    });
+                  }
                 });
-              }
-              else {
-                connection.commit(function (er3) {
-                  if (er3) {
+              })];
+          }
+          return [3, 18];
+        case 1:
+          if (!firstSuccess) return [3, 11];
+          _a.label = 2;
+        case 2:
+          _a.trys.push([2, 9, , 10]);
+          return [4, beginTransaction(connection, true)];
+        case 3:
+          _a.sent();
+          return [4, execute(connection, statements[0].query, toArray(statements[0].params))];
+        case 4:
+          count_1 = _a.sent();
+          if (count_1 === 0) {
+            commit(connection, true);
+            return [2, 0];
+          }
+          l = statements.length;
+          j = 1;
+          _a.label = 5;
+        case 5:
+          if (!(j < l)) return [3, 8];
+          item = statements[j];
+          return [4, execute(connection, item.query, toArray(item.params))];
+        case 6:
+          c = _a.sent();
+          count_1 = count_1 + c;
+          _a.label = 7;
+        case 7:
+          j++;
+          return [3, 5];
+        case 8:
+          commit(connection, true);
+          return [2, count_1];
+        case 9:
+          err_1 = _a.sent();
+          rollback(connection);
+          throw err_1;
+        case 10: return [3, 18];
+        case 11:
+          _a.trys.push([11, 17, , 18]);
+          return [4, beginTransaction(connection, true)];
+        case 12:
+          _a.sent();
+          count_2 = 0;
+          l = statements.length;
+          j = 0;
+          _a.label = 13;
+        case 13:
+          if (!(j < l)) return [3, 16];
+          item = statements[j];
+          return [4, execute(connection, item.query, toArray(item.params))];
+        case 14:
+          c = _a.sent();
+          count_2 = count_2 + c;
+          _a.label = 15;
+        case 15:
+          j++;
+          return [3, 13];
+        case 16:
+          commit(connection, true);
+          return [2, count_2];
+        case 17:
+          err_2 = _a.sent();
+          rollback(connection);
+          throw err_2;
+        case 18: return [2];
+      }
+    });
+  });
+}
+exports.executeBatchConnectionTx = executeBatchConnectionTx;
+function executeBatchConnection(connection, statements, firstSuccess) {
+  return __awaiter(this, void 0, void 0, function () {
+    var count_3, l, j, item, c, er1_1, er0_1, count_4, l, j, item, c, err_3;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          if (!statements || statements.length === 0) {
+            return [2, Promise.resolve(0)];
+          }
+          else if (statements.length === 1) {
+            return [2, execute(connection, statements[0].query, statements[0].params)];
+          }
+          if (!resource.multipleStatements) return [3, 1];
+          if (firstSuccess) {
+            return [2, new Promise(function (resolve, reject) {
+                connection.execute(statements[0].query, toArray(statements[0].params), function (er2a, results0) {
+                  if (er2a) {
+                    return reject(er2a);
+                  }
+                  else {
+                    if (results0 && results0.affectedRows === 0) {
+                      return 0;
+                    }
+                    else {
+                      var queries = [];
+                      var params = [];
+                      var l = statements.length;
+                      for (var j = 1; j < l; j++) {
+                        var item = statements[j];
+                        if (item.query.endsWith(";")) {
+                          queries.push(item.query);
+                        }
+                        else {
+                          queries.push(item.query + ";");
+                        }
+                        if (item.params && item.params.length > 0) {
+                          for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
+                            var p = _a[_i];
+                            params.push(p);
+                          }
+                        }
+                      }
+                      connection.query(queries.join(""), toArray(params), function (er2, results) {
+                        if (er2) {
+                          return reject(er2);
+                        }
+                        else {
+                          var c = 0;
+                          c += results0.affectedRows + results.affectedRows;
+                          return resolve(c);
+                        }
+                      });
+                    }
+                  }
+                });
+              })];
+          }
+          else {
+            return [2, new Promise(function (resolve, reject) {
+                var queries = [];
+                var params = [];
+                statements.forEach(function (item) {
+                  if (item.query.endsWith(";")) {
+                    queries.push(item.query);
+                  }
+                  else {
+                    queries.push(item.query + ";");
+                  }
+                  if (item.params && item.params.length > 0) {
+                    for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
+                      var p = _a[_i];
+                      params.push(p);
+                    }
+                  }
+                });
+                connection.query(queries.join(""), toArray(params), function (er2, results) {
+                  if (er2) {
                     connection.rollback(function () {
-                      return reject(er3);
+                      buildError(er2);
+                      return reject(er2);
                     });
                   }
+                  else {
+                    connection.commit(function (er3) {
+                      if (er3) {
+                        connection.rollback(function () {
+                          return reject(er3);
+                        });
+                      }
+                    });
+                    return resolve(results.affectedRows);
+                  }
                 });
-                return resolve(results.affectedRows);
-              }
-            });
+              })];
           }
-        });
-      });
+          return [3, 20];
+        case 1:
+          if (!firstSuccess) return [3, 13];
+          _a.label = 2;
+        case 2:
+          _a.trys.push([2, 11, , 12]);
+          return [4, execute(connection, statements[0].query, toArray(statements[0].params))];
+        case 3:
+          count_3 = _a.sent();
+          if (count_3 === 0) {
+            return [2, 0];
+          }
+          l = statements.length;
+          _a.label = 4;
+        case 4:
+          _a.trys.push([4, 9, , 10]);
+          j = 1;
+          _a.label = 5;
+        case 5:
+          if (!(j < l)) return [3, 8];
+          item = statements[j];
+          return [4, execute(connection, item.query, toArray(item.params))];
+        case 6:
+          c = _a.sent();
+          count_3 = count_3 + c;
+          _a.label = 7;
+        case 7:
+          j++;
+          return [3, 5];
+        case 8: return [2, count_3];
+        case 9:
+          er1_1 = _a.sent();
+          throw er1_1;
+        case 10: return [3, 12];
+        case 11:
+          er0_1 = _a.sent();
+          throw er0_1;
+        case 12: return [3, 20];
+        case 13:
+          count_4 = 0;
+          l = statements.length;
+          _a.label = 14;
+        case 14:
+          _a.trys.push([14, 19, , 20]);
+          j = 0;
+          _a.label = 15;
+        case 15:
+          if (!(j < l)) return [3, 18];
+          item = statements[j];
+          return [4, execute(connection, item.query, toArray(item.params))];
+        case 16:
+          c = _a.sent();
+          count_4 = count_4 + c;
+          _a.label = 17;
+        case 17:
+          j++;
+          return [3, 15];
+        case 18: return [2, count_4];
+        case 19:
+          err_3 = _a.sent();
+          throw err_3;
+        case 20: return [2];
+      }
     });
-  }
+  });
 }
-exports.execBatch = execBatch;
+exports.executeBatchConnection = executeBatchConnection;
 function buildError(err) {
   if (err.errno === 1062 && err.code === "ER_DUP_ENTRY") {
     err.error = "duplicate";
   }
   return err;
 }
-function exec(pool, sql, args) {
+function execute(pool, sql, args) {
   return __awaiter(this, void 0, void 0, function () {
     var p;
     return __generator(this, function (_a) {
@@ -256,7 +787,7 @@ function exec(pool, sql, args) {
     });
   });
 }
-exports.exec = exec;
+exports.execute = execute;
 function query(pool, sql, args, m, bools) {
   return __awaiter(this, void 0, void 0, function () {
     var p;
@@ -295,7 +826,7 @@ function queryOne(pool, sql, args, m, bools) {
   });
 }
 exports.queryOne = queryOne;
-function execScalar(pool, sql, args) {
+function executeScalar(pool, sql, args) {
   return queryOne(pool, sql, args).then(function (r) {
     if (!r) {
       return null;
@@ -306,21 +837,21 @@ function execScalar(pool, sql, args) {
     }
   });
 }
-exports.execScalar = execScalar;
+exports.executeScalar = executeScalar;
 function count(pool, sql, args) {
-  return execScalar(pool, sql, args);
+  return executeScalar(pool, sql, args);
 }
 exports.count = count;
 function save(pool, obj, table, attrs, ver, buildParam, i) {
   var s = build_1.buildToSave(obj, table, attrs, ver, buildParam);
-  if (!s) {
+  if (!s.query) {
     return Promise.resolve(-1);
   }
   if (typeof pool === "function") {
     return pool(s.query, s.params);
   }
   else {
-    return exec(pool, s.query, s.params);
+    return execute(pool, s.query, s.params);
   }
 }
 exports.save = save;
@@ -330,7 +861,7 @@ function saveBatch(pool, objs, table, attrs, ver, buildParam) {
     return pool(s);
   }
   else {
-    return execBatch(pool, s);
+    return executeBatch(pool, s);
   }
 }
 exports.saveBatch = saveBatch;
@@ -549,7 +1080,7 @@ var StringService = (function () {
       arr.push("(?)");
     }
     var s = "insert ignore into " + this.table + "(" + this.column + ")values" + arr.join(",");
-    return exec(this.pool, s, values);
+    return execute(this.pool, s, values);
   };
   return StringService;
 }());
@@ -574,7 +1105,7 @@ var MySQLWriter = (function () {
     this.oneIfSuccess = oneIfSuccess;
     this.write = this.write.bind(this);
     if (typeof pool === "function") {
-      this.exec = pool;
+      this.execute = pool;
     }
     else {
       this.pool = pool;
@@ -596,20 +1127,20 @@ var MySQLWriter = (function () {
     }
     var stmt = build_1.buildToSave(obj2, this.table, this.attributes, this.version, this.param);
     if (stmt) {
-      if (this.exec) {
+      if (this.execute) {
         if (this.oneIfSuccess) {
-          return this.exec(stmt.query, stmt.params).then(function (ct) { return (ct > 0 ? 1 : 0); });
+          return this.execute(stmt.query, stmt.params).then(function (ct) { return (ct > 0 ? 1 : 0); });
         }
         else {
-          return this.exec(stmt.query, stmt.params);
+          return this.execute(stmt.query, stmt.params);
         }
       }
       else {
         if (this.oneIfSuccess) {
-          return exec(this.pool, stmt.query, stmt.params).then(function (ct) { return (ct > 0 ? 1 : 0); });
+          return execute(this.pool, stmt.query, stmt.params).then(function (ct) { return (ct > 0 ? 1 : 0); });
         }
         else {
-          return exec(this.pool, stmt.query, stmt.params);
+          return execute(this.pool, stmt.query, stmt.params);
         }
       }
     }
@@ -629,7 +1160,7 @@ var MySQLStreamWriter = (function () {
     this.write = this.write.bind(this);
     this.flush = this.flush.bind(this);
     if (typeof pool === "function") {
-      this.execBatch = pool;
+      this.executeBatch = pool;
     }
     else {
       this.pool = pool;
@@ -672,14 +1203,14 @@ var MySQLStreamWriter = (function () {
       var total_1 = this.list.length;
       var stmt = build_1.buildToSaveBatch(this.list, this.table, this.attributes, this.version, this.param);
       if (stmt) {
-        if (this.execBatch) {
-          return this.execBatch(stmt).then(function (r) {
+        if (this.executeBatch) {
+          return this.executeBatch(stmt).then(function (r) {
             _this.list = [];
             return total_1;
           });
         }
         else {
-          return execBatch(this.pool, stmt).then(function (r) {
+          return executeBatch(this.pool, stmt).then(function (r) {
             _this.list = [];
             return total_1;
           });
@@ -737,10 +1268,10 @@ var MySQLBatchWriter = (function () {
       }
       else {
         if (this.oneIfSuccess) {
-          return execBatch(this.pool, stmts).then(function (ct) { return stmts.length; });
+          return executeBatch(this.pool, stmts).then(function (ct) { return stmts.length; });
         }
         else {
-          return execBatch(this.pool, stmts);
+          return executeBatch(this.pool, stmts);
         }
       }
     }