mm_sqlite 1.1.2 → 1.1.4

package/LICENSE

@@ -1,201 +1,21 @@
-Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+MIT License
+
+Copyright (c) 2024 邱文武
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,6 +2,11 @@
 
 高性能SQLite数据库操作模块，提供与mm_mysql完全兼容的API接口。适用于Node.js应用的轻量级数据存储解决方案。
 
+[![npm version](https://img.shields.io/npm/v/mm_sqlite.svg?style=flat-square)](https://www.npmjs.com/package/mm_sqlite)
+[![npm downloads](https://img.shields.io/npm/dm/mm_sqlite.svg?style=flat-square)](https://www.npmjs.com/package/mm_sqlite)
+[![node version](https://img.shields.io/node/v/mm_sqlite.svg?style=flat-square)](https://nodejs.org/en/)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE)
+
 ## 特性
 
 - 🚀 **高性能优化**：经过深度优化的SQL构建器和连接管理
@@ -13,18 +18,21 @@
 
 ## 安装
 
-通过npm安装模块：
-
+### 使用 npm
 ```bash
 npm install mm_sqlite --save
 ```
 
-通过yarn安装模块：
-
+### 使用 yarn
 ```bash
 yarn add mm_sqlite
 ```
 
+### 使用 pnpm
+```bash
+pnpm add mm_sqlite
+```
+
 ## 依赖要求
 
 - Node.js 14.0+
@@ -41,11 +49,12 @@ const { Sqlite } = require('mm_sqlite');
 
 // 创建数据库实例
 const sqlite = new Sqlite({
-    database: './data/test.db',     // 数据库文件路径
-    timeout: 30000,                 // 查询超时时间（毫秒）
-    retry_count: 3,                 // 失败重试次数
-    conn_timeout: 30000,            // 连接超时时间（毫秒）
-    enablePerformanceLog: false     // 是否启用性能日志
+    dir: './db/',                  // 数据库文件存储目录
+    database: 'test',              // 数据库文件名（不包含扩展名）
+    timeout: 30000,                // 查询超时时间（毫秒）
+    retry_count: 3,                // 失败重试次数
+    conn_timeout: 30000,           // 连接超时时间（毫秒）
+    enablePerformanceLog: false    // 是否启用性能日志
 });
 
 // 打开数据库连接
@@ -165,14 +174,14 @@ await sqlite.beginTransaction();
 
 try {
     // 插入数据
-    await sqlite.table('users').insert({
+    await sqlite.table('users').add({
         name: '张三',
         email: 'zhangsan@example.com',
         status: 'active'
     });
 
-    // 更新数据
-    await sqlite.table('profiles').insert({
+    // 插入关联数据
+    await sqlite.table('profiles').add({
         user_id: 1,
         bio: '这是一个测试用户'
     });
@@ -242,21 +251,27 @@ const users = await sqlite
 new Sqlite(config)
 ```
 
-**参数：**
-- `config.database` - 数据库文件路径，默认为`'./db.sqlite'`
+**配置参数：**
+- `config.dir` - 数据库文件存储目录，默认为`'./db/'`
+- `config.database` - 数据库文件名，默认为`'mm'`
 - `config.timeout` - 查询超时时间，默认`30000ms`
 - `config.retry_count` - 失败重试次数，默认`3`
 - `config.conn_timeout` - 连接超时时间，默认`30000ms`
-- `config.enablePerformanceLog` - 是否启用性能日志，默认false
+- `config.enablePerformanceLog` - 是否启用性能日志，默认`false`
+- `config.debug` - 是否启用调试模式，默认`false`
 
 #### 主要方法
 
-- `getConnection()` - 获取数据库连接，返回Promise<Connection>
-- `closeConnection(conn)` - 关闭数据库连接，返回Promise<Boolean>
-- `run(sql, params)` - 执行SQL语句（非查询操作），返回Promise<Object>
-- `exec(sql, params)` - 执行SQL查询，返回Promise<Array>
-- `transaction(fn)` - 执行事务，返回Promise<any>
-- `table(tableName)` - 设置表名，返回Sql实例
+- `open(timeout)` - 打开数据库连接，返回`Promise<Boolean>`
+- `close()` - 关闭数据库连接，返回`Promise<Boolean>`
+- `getConn(timeout)` - 获取数据库连接，返回`Promise<Connection>`
+- `run(sql, params, timeout)` - 执行SQL语句（非查询操作），返回`Promise<Object>`
+- `exec(sql, params, timeout)` - 执行SQL查询，返回`Promise<Array>`
+- `beginTransaction()` - 开始事务，返回`Promise<void>`
+- `commit()` - 提交事务，返回`Promise<void>`
+- `rollback()` - 回滚事务，返回`Promise<void>`
+- `transaction(fn)` - 执行事务，返回`Promise<any>`
+- `table(tableName)` - 设置表名，返回`Sql`实例
 
 ### Sql类
 
@@ -339,6 +354,12 @@ A: 可以使用相对路径或绝对路径。建议使用绝对路径以避免
 **Q: 事务处理是否支持嵌套？**
 A: 目前不支持嵌套事务，但可以在一个事务中执行多个操作。
 
+**Q: 如何启用调试模式？**
+A: 在创建Sqlite实例时，设置`debug: true`配置项即可启用调试模式。
+
+**Q: 如何处理SQLite的锁问题？**
+A: 避免长时间运行的事务，使用适当的事务隔离级别，并确保在操作完成后及时提交或回滚事务。
+
 ## 许可证
 
 MIT License
@@ -350,3 +371,13 @@ MIT License
 1. 运行测试确保功能正常
 2. 添加适当的注释和文档
 3. 遵循项目的代码风格
+4. 确保代码符合ES6+标准
+5. 提交前请先拉取最新代码，解决冲突
+
+### 开发流程
+
+1. Fork 仓库
+2. 创建特性分支 (`git checkout -b feature/AmazingFeature`)
+3. 提交更改 (`git commit -m 'Add some AmazingFeature'`)
+4. 推送到分支 (`git push origin feature/AmazingFeature`)
+5. 打开 Pull Request

package/db.js

@@ -896,4 +896,41 @@ DB.prototype.backup = function(table, backup, timeout = 60000) {
 	}
 };
 
+/**
+ * @description 创建表
+ * @param {String} table 表名
+ * @param {Object} model 表模型，键值对，根据值类型创建字段类型，根据键名创建字段名
+ * @param {String} key 主键
+ * @return {Promise|Number} 操作结果
+ */
+DB.prototype.createTable = function(table, model, key = 'id', timeout = 15000){
+	if (!table || !model || !model.fields) {
+		$.log.error("[DB] [createTable] 参数不完整");
+		return 0;
+	}
+	var fields = '';
+	for (const field in model.fields) {
+		const value = model.fields[field];
+		let type = '';
+		if (field === key) {
+			type = 'INTEGER PRIMARY KEY AUTOINCREMENT';
+		} else if (typeof value === 'number') {
+			if (value % 1 === 0) {
+				type = 'INTEGER';
+			} else {
+				type = 'REAL';
+			}
+		} else if (typeof value === 'string') {
+			type = 'TEXT';
+		}
+		else {
+			type = 'BLOB';
+		}
+		fields += `\`${field}\` ${type}, `;
+	}
+	fields = fields.slice(0, -2);
+	var sql = `CREATE TABLE IF NOT EXISTS \`${table}\` (${fields});`;
+	return this.exec(sql, [], timeout);
+}
+
 module.exports = DB;

package/index.js

@@ -1,7 +1,6 @@
 const sqlite3 = require('sqlite3').verbose();
 const DB = require('./db');
 const { BaseService } = require('mm_base_service');
-
 /**
  * SQLite数据库操作类
  * @class Sqlite
@@ -12,8 +11,7 @@ class Sqlite extends BaseService {
    * 默认配置
    */
   static default_config = {
-    host: "/db/".fullname(),
-    port: 3306,
+    dir: "./db/".fullname(),
     user: "root",
     password: "",
     database: "mm",
@@ -39,7 +37,7 @@ class Sqlite extends BaseService {
   constructor(config) {
     const merged_config = Object.assign({}, Sqlite.default_config, config || {});
     super(merged_config);
-    
+
     this.config = merged_config;
     this._connection = null;
     this._pool = null;
@@ -58,7 +56,7 @@ class Sqlite extends BaseService {
  * 初始化服务
  * @returns {Promise<void>}
  */
-Sqlite.prototype._initService = async function() {
+Sqlite.prototype._initService = async function () {
   if (this._is_inited) {
     $.log.warn('SQLite服务已初始化');
     return;
@@ -79,7 +77,7 @@ Sqlite.prototype._initService = async function() {
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise<boolean>}
  */
-Sqlite.prototype.open = async function(timeout) {
+Sqlite.prototype.open = async function (timeout) {
   if (this._status === 'connected' || this._status === 'connecting') {
     $.log.warn('数据库连接已存在或正在连接中');
     return true;
@@ -89,14 +87,6 @@ Sqlite.prototype.open = async function(timeout) {
   this._status = 'connecting';
 
   try {
-    // $.log.debug(`[${this.constructor.name}] [open]`, '开始创建数据库连接', {
-    //   host: this.config.host,
-    //   port: this.config.port,
-    //   database: this.config.database,
-    //   user: this.config.user,
-    //   timeout: timeout
-    // });
-
     // 创建连接
     const connection_promise = this._openInternal();
     const timeout_promise = new Promise((_, reject) => {
@@ -111,8 +101,7 @@ Sqlite.prototype.open = async function(timeout) {
       this._last_connect_time = Date.now();
       this._status = 'connected';
       $.log.info(`[${this.constructor.name}] [open]`, '数据库连接成功', {
-        host: this.config.host,
-        port: this.config.port,
+        dir: this.config.dir,
         database: this.config.database
       });
       return true;
@@ -122,7 +111,7 @@ Sqlite.prototype.open = async function(timeout) {
         code: connection_err.code,
         syscall: connection_err.syscall,
         address: connection_err.address,
-        port: connection_err.port,
+        dir: connection_err.dir,
         stack: connection_err.stack
       });
       throw connection_err;
@@ -131,8 +120,7 @@ Sqlite.prototype.open = async function(timeout) {
     this._status = 'closed';
     $.log.error(`[${this.constructor.name}] [open]`, '数据库连接失败', {
       error: err.message,
-      host: this.config.host,
-      port: this.config.port,
+      dir: this.config.dir,
       database: this.config.database
     });
     throw err;
@@ -144,32 +132,29 @@ Sqlite.prototype.open = async function(timeout) {
  * @private
  * @returns {Promise<void>}
  */
-Sqlite.prototype._openInternal = function() {
+Sqlite.prototype._openInternal = function () {
   return new Promise((resolve, reject) => {
     try {
-      const fs = require('fs');
-      const path = require('path');
-      
+
       // 确保数据库目录存在
-      const db_path = this._getDatabasePath();
-      const dir = path.dirname(db_path);
-      
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+      const file = this._getDatabasePath();
+
+      if (!file.hasDir()) {
+        file.addDir();
       }
-      
+
       // 创建数据库连接
-      this._db = new sqlite3.Database(db_path);
+      this._db = new sqlite3.Database(file);
       this._open = true;
       this._conn_retry_count = 0;
-      
+
       // 设置连接错误处理
       this._db.on('error', (err) => {
         $.log.error('SQLite数据库连接错误:', err);
         this._handleConnectionError(err);
       });
-      
-      $.log.debug(`SQLite数据库已打开: ${db_path}`);
+
+      $.log.debug(`SQLite数据库已打开: ${file}`);
       resolve();
     } catch (error) {
       reject(error);
@@ -182,17 +167,20 @@ Sqlite.prototype._openInternal = function() {
  * @private
  * @returns {String}
  */
-Sqlite.prototype._getDatabasePath = function() {
+Sqlite.prototype._getDatabasePath = function () {
   const db_name = this.config.database || 'mm';
-  const db_dir = this.config.host || '/db/';
-  return `${db_dir}${db_name}.db`;
+  if (db_name.endsWith('.db')) {
+    db_name = db_name.replace('.db', '');
+  }
+  const db_dir = this.config.dir || '/db/'.fullname();
+  return `./${db_name}.db`.fullname(db_dir);
 };
 
 /**
  * 关闭数据库连接
  * @returns {Promise<boolean>}
  */
-Sqlite.prototype.close = function() {
+Sqlite.prototype.close = function () {
   if (this._status !== 'connected') {
     $.log.warn('数据库连接未建立');
     return Promise.resolve(false);
@@ -230,7 +218,7 @@ Sqlite.prototype.close = function() {
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise<Object>}
  */
-Sqlite.prototype.getConn = async function(timeout) {
+Sqlite.prototype.getConn = async function (timeout) {
   timeout = timeout || this.config.acquire_timeout || this.config.connect_timeout || 20000;
 
   // $.log.debug(`[${this.constructor.name}] [getConn] 使用超时时间: ${timeout}ms`);
@@ -279,7 +267,7 @@ Sqlite.prototype.getConn = async function(timeout) {
  * @private
  * @param {Error} err - 错误对象
  */
-Sqlite.prototype._handleConnectionError = function(err) {
+Sqlite.prototype._handleConnectionError = function (err) {
   if (this._reconnecting) {
     $.log.debug('重连已在进行中');
     return;
@@ -304,7 +292,7 @@ Sqlite.prototype._handleConnectionError = function(err) {
  * @param {Number} max_retries - 最大重试次数
  * @returns {Promise<boolean>}
  */
-Sqlite.prototype._reconnect = async function(max_retries) {
+Sqlite.prototype._reconnect = async function (max_retries) {
   if (this._reconnecting) {
     $.log.warn('重连已在进行中');
     return false;
@@ -353,7 +341,7 @@ Sqlite.prototype._reconnect = async function(max_retries) {
  * @param {Number} ms - 休眠时间(毫秒)
  * @returns {Promise<void>}
  */
-Sqlite.prototype._sleep = function(ms) {
+Sqlite.prototype._sleep = function (ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 };
 
@@ -364,7 +352,7 @@ Sqlite.prototype._sleep = function(ms) {
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise<Object>}
  */
-Sqlite.prototype.run = async function(sql, params, timeout) {
+Sqlite.prototype.run = async function (sql, params, timeout) {
   let conn = null;
   timeout = timeout || this.config.query_timeout || 30000;
 
@@ -383,7 +371,7 @@ Sqlite.prototype.run = async function(sql, params, timeout) {
         }
       });
     });
-    
+
     const timeout_promise = new Promise((_, reject) => {
       setTimeout(() => {
         reject(new Error(`SQL查询超时: ${timeout}ms`));
@@ -416,7 +404,7 @@ Sqlite.prototype.run = async function(sql, params, timeout) {
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise<Object>}
  */
-Sqlite.prototype.exec = async function(sql, params, timeout) {
+Sqlite.prototype.exec = async function (sql, params, timeout) {
   let conn = null;
   timeout = timeout || this.config.query_timeout || 30000;
 
@@ -426,7 +414,7 @@ Sqlite.prototype.exec = async function(sql, params, timeout) {
 
     // 直接在方法内部实现超时控制
     const query_promise = new Promise((resolve, reject) => {
-      conn.run(sql, params || [], function(error) {
+      conn.run(sql, params || [], function (error) {
         if (error) {
           reject(error);
         } else {
@@ -439,7 +427,7 @@ Sqlite.prototype.exec = async function(sql, params, timeout) {
         }
       });
     });
-    
+
     const timeout_promise = new Promise((_, reject) => {
       setTimeout(() => {
         reject(new Error(`SQL执行超时: ${timeout}ms`));
@@ -472,7 +460,7 @@ Sqlite.prototype.exec = async function(sql, params, timeout) {
  * @param {Object} options - 选项（order_by, limit, offset等）
  * @returns {Promise<Array>}
  */
-Sqlite.prototype.read = async function(table, condition, options) {
+Sqlite.prototype.read = async function (table, condition, options) {
   try {
     // 检查连接状态
     if (this._status !== 'connected') {
@@ -539,24 +527,24 @@ Sqlite.prototype.read = async function(table, condition, options) {
  * @param {String} database - 数据库名称
  * @returns {Object} 数据库操作实例
  */
-Sqlite.prototype.db = function(database) {
+Sqlite.prototype.db = function (database) {
   if (this._status !== 'connected') {
     throw new Error('数据库连接未建立');
   }
-  
+
   // 优化：缓存DB实例，避免重复创建
   if (!this._db_instance) {
     this._db_instance = new DB(this);
-    
+
     // 为DB实例添加必要的方法，确保与MySQL接口兼容
     this._db_instance.run = this.run.bind(this);
     this._db_instance.exec = this.exec.bind(this);
   }
-  
+
   if (database) {
     this._db_instance.database = database;
   }
-  
+
   return this._db_instance;
 };
 
@@ -564,7 +552,7 @@ Sqlite.prototype.db = function(database) {
  * 获取数据库管理器模型
  * @returns {Object} 数据库管理器模型
  */
-Sqlite.prototype.dbs = function() {
+Sqlite.prototype.dbs = function () {
   return this.db();
 };
 
@@ -572,7 +560,7 @@ Sqlite.prototype.dbs = function() {
  * 开始事务
  * @returns {Promise<Object>} 事务连接对象
  */
-Sqlite.prototype.beginTransaction = async function() {
+Sqlite.prototype.beginTransaction = async function () {
   try {
     // 检查连接状态
     if (this._status !== 'connected') {
@@ -631,7 +619,7 @@ Sqlite.prototype.beginTransaction = async function() {
       exec: async (sql, params) => {
         // 在事务中执行SQL
         return new Promise((resolve, reject) => {
-          connection.run(sql, params || [], function(error) {
+          connection.run(sql, params || [], function (error) {
             if (error) {
               reject(error);
             } else {
@@ -658,7 +646,7 @@ Sqlite.prototype.beginTransaction = async function() {
  * @param {Function} callback - 包含事务操作的回调函数
  * @returns {Promise<*>} 回调函数的返回值
  */
-Sqlite.prototype.transaction = async function(callback) {
+Sqlite.prototype.transaction = async function (callback) {
   let transaction = null;
 
   try {
@@ -685,14 +673,31 @@ Sqlite.prototype.transaction = async function(callback) {
   }
 };
 
+/**
+ * 设置当前操作的表名
+ * @param {String} name - 表名
+ * @param {String} key  - 主键
+ * @returns {Object} 数据库操作实例
+ */
+Sqlite.prototype.table = function (name, key) {
+  var db = this.db();
+  db.table = name;
+  if (key) {
+    db.key = key;
+  }
+  return db;
+};
+
+// close 方法已在文件前面部分实现，这里不再重复
+
 /**
  * 确保连接池对象存在
  */
 if (!$.pool) {
-	$.pool = {};
+  $.pool = {};
 }
 if (!$.pool.sqlite) {
-	$.pool.sqlite = {};
+  $.pool.sqlite = {};
 }
 
 /**
@@ -702,15 +707,15 @@ if (!$.pool.sqlite) {
  * @return {Object} 返回一个Sqlite类实例
  */
 function sqliteAdmin(scope, config) {
-	if (!scope) {
-		scope = 'sys';
-	}
-	var obj = $.pool.sqlite[scope];
-	if (!obj) {
-		$.pool.sqlite[scope] = new Sqlite(config);
-		obj = $.pool.sqlite[scope];
-	}
-	return obj;
+  if (!scope) {
+    scope = 'sys';
+  }
+  var obj = $.pool.sqlite[scope];
+  if (!obj) {
+    $.pool.sqlite[scope] = new Sqlite(config);
+    obj = $.pool.sqlite[scope];
+  }
+  return obj;
 }
 
 // 模块导出

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_sqlite",
-    "version": "1.1.2",
+    "version": "1.1.4",
     "description": "高性能SQLite数据库操作模块，提供与mm_mysql完全兼容的API接口，支持异步操作、事务处理和批量操作",
     "main": "index.js",
     "scripts": {
@@ -36,7 +36,7 @@
         "node": ">=14.0.0"
     },
     "dependencies": {
-        "mm_logs": "^1.5.4",
+        "mm_base_service": "^1.0.2",
         "sqlite3": "^5.1.7",
         "sqlstring": "^2.3.3"
     }

package/config.json

@@ -1,8 +0,0 @@
-{
-	"host": "localhost",
-	"port": 3306,
-	"user": "root",
-	"password": "asd159357",
-	"database": "mm",
-	"multipleStatements": true
-}

package/test.js

@@ -1,81 +0,0 @@
-const Sqlite = require('./index.js').Sqlite;
-
-// 全面测试函数
-async function runAllTests() {
-	$.log.info('开始全面测试mm_sqlite模块...');
-	var sql = new Sqlite();
-	await sql.open();
-	
-	var test_table = 'test_mm_sqlite';
-	
-	try {
-		// 1. 测试表创建
-		$.log.info('1. 测试表创建...');
-		let create_sql = `CREATE TABLE IF NOT EXISTS ${test_table} (
-			uid INTEGER PRIMARY KEY AUTOINCREMENT,
-			username VARCHAR(50) NOT NULL,
-			age INTEGER DEFAULT 0,
-			created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-		)`;
-		let create_result = await sql.run(create_sql);
-		$.log.info('表创建结果:', create_result);
-		
-		// 2. 测试数据插入
-		$.log.info('2. 测试数据插入...');
-		let insert_sql = `INSERT INTO ${test_table} (username, age) VALUES (?, ?)`;
-		let insert_result = await sql.run(insert_sql, ['test_user_1', 25]);
-		$.log.info('插入结果:', insert_result);
-		
-		// 3. 测试查询 - 使用exec方法并安全处理返回结果
-		$.log.info('3. 测试查询...');
-		let query_sql = `SELECT * FROM ${test_table}`;
-		let query_result = await sql.exec(query_sql);
-		$.log.info('查询结果类型:', typeof query_result);
-		$.log.info('查询结果:', query_result);
-		
-		// 4. 测试更新
-		$.log.info('4. 测试更新...');
-		let update_sql = `UPDATE ${test_table} SET age = ? WHERE username = ?`;
-		let update_result = await sql.run(update_sql, [26, 'test_user_1']);
-		$.log.info('更新结果:', update_result);
-		
-		// 5. 测试删除
-		$.log.info('5. 测试删除...');
-		let delete_sql = `DELETE FROM ${test_table} WHERE username = ?`;
-		let delete_result = await sql.run(delete_sql, ['test_user_1']);
-		$.log.info('删除结果:', delete_result);
-		
-		// 6. 测试事务
-		$.log.info('6. 测试事务...');
-		let transaction_result = await sql.transaction(async () => {
-			await sql.run(`INSERT INTO ${test_table} (username, age) VALUES (?, ?)`, ['transaction_user', 40]);
-			return await sql.run(`DELETE FROM ${test_table} WHERE username = ?`, ['transaction_user']);
-		});
-		$.log.info('事务结果:', transaction_result);
-		
-		// 7. 测试表列表 - 安全处理exec返回结果
-		$.log.info('7. 测试表列表...');
-		let tables_sql = `SELECT name FROM sqlite_master WHERE type='table'`;
-		let tables_result = await sql.exec(tables_sql);
-		$.log.info('表列表类型:', typeof tables_result);
-		$.log.info('表列表:', tables_result);
-		
-		// 8. 清理测试表
-		$.log.info('8. 清理测试表...');
-		let drop_result = await sql.run(`DROP TABLE IF EXISTS ${test_table}`);
-		$.log.info('删除表结果:', drop_result);
-		
-		$.log.info('所有测试完成！mm_sqlite模块功能正常。');
-		return true;
-	} catch (error) {
-		$.log.error('测试过程中发生错误:', error);
-		return false;
-	} finally {
-		await sql.close();
-	}
-}
-
-// 运行测试
-(async function() {
-	await runAllTests();
-})();

package/test_all_methods.js

@@ -1,115 +0,0 @@
-// 核心方法测试脚本 - 专注测试del、delList等关键方法
-const { Sqlite } = require('./index');
-
-async function testAllMethods() {
-    try {
-        console.log('=== 开始测试 SQLite 模块核心方法 ===');
-        
-        // 初始化SQLite实例
-        const sql = new Sqlite({
-            database: './db/test_core_methods.db'
-        });
-        
-        await sql.open();
-        console.log('数据库连接成功');
-        
-        // 获取数据库操作实例
-        const db = sql.db();
-        const test_table = 'test_core_methods';
-        
-        // 准备测试表
-        console.log('\n=== 1. 准备测试环境 ===');
-        await db.exec(`DROP TABLE IF EXISTS ${test_table};`);
-        await db.exec(`CREATE TABLE IF NOT EXISTS ${test_table} (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            username VARCHAR(50) NOT NULL,
-            email VARCHAR(100),
-            age INTEGER DEFAULT 0 NOT NULL
-        );`);
-        console.log('测试表创建完成');
-        
-        db.table = test_table;
-        
-        // 2. 单条数据操作测试
-        console.log('\n=== 2. 单条数据操作测试 ===');
-        // 添加单条数据
-        const addResult = await db.add({
-            username: 'test_user1',
-            email: 'test1@example.com',
-            age: 25
-        });
-        console.log('✓ add方法测试通过:', addResult);
-        
-        // 查询单条数据
-        const getResult = await db.get({ username: 'test_user1' });
-        console.log('✓ get方法测试通过，数据:', getResult[0]?.username);
-        
-        // 修改数据
-        const setResult = await db.set(
-            { username: 'test_user1' },
-            { age: 26 }
-        );
-        console.log('✓ set方法测试通过:', setResult);
-        
-        // 3. 批量操作测试 - 重点测试addList
-        console.log('\n=== 3. 批量添加测试 ===');
-        const batchData = [
-            { username: 'batch_user1', email: 'batch1@example.com', age: 30 },
-            { username: 'batch_user2', email: 'batch2@example.com', age: 31 },
-            { username: 'batch_user3', email: 'batch3@example.com', age: 32 }
-        ];
-        
-        const addListResult = await db.addList(batchData);
-        console.log('✓ addList方法测试通过:', addListResult);
-        
-        // 4. 单条删除测试 - 重点测试del
-        console.log('\n=== 4. 单条删除测试 ===');
-        const delResult = await db.del({ username: 'test_user1' });
-        console.log('✓ del方法测试通过:', delResult);
-        
-        // 验证删除结果
-        const delCheck = await db.get({ username: 'test_user1' });
-        console.log('  del方法验证结果: 删除成功', delCheck.length === 0);
-        
-        // 5. 批量删除测试 - 重点测试delList
-        console.log('\n=== 5. 批量删除测试 ===');
-        const deleteList = [
-            { query: { username: 'batch_user1' } },
-            { query: { username: 'batch_user2' } }
-        ];
-        
-        const delListResult = await db.delList(deleteList);
-        console.log('✓ delList方法测试通过:', delListResult);
-        
-        // 验证批量删除结果
-        const batch1Check = await db.get({ username: 'batch_user1' });
-        const batch2Check = await db.get({ username: 'batch_user2' });
-        console.log('  delList方法验证结果: 批量删除成功', 
-                   batch1Check.length === 0 && batch2Check.length === 0);
-        
-        // 验证剩余数据
-        const remainingData = await db.get({});
-        console.log('  剩余数据数量:', remainingData.length);
-        
-        // 6. 清理测试数据
-        console.log('\n=== 6. 清理测试环境 ===');
-        await db.exec(`DROP TABLE IF EXISTS ${test_table};`);
-        console.log('测试表清理完成');
-        
-        // 关闭数据库连接
-        await sql.close();
-        console.log('\n=== 核心方法测试完成！===');
-        console.log('✓ del方法工作正常');
-        console.log('✓ delList方法工作正常');
-        console.log('✓ 其他核心方法(add, get, set, addList)工作正常');
-        
-    } catch (error) {
-        console.error('测试过程中出现错误:', error.message);
-        console.error('错误堆栈:', error.stack);
-    }
-}
-
-// 执行测试
-(async () => {
-    await testAllMethods();
-})();

package/test_db_methods.js

@@ -1,262 +0,0 @@
-// 测试db.js中的所有方法
-const { Sqlite } = require('./index');
-const path = require('path');
-
-async function testDbMethods() {
-    let sql;
-    try {
-        console.log('=== 开始测试 mm_sqlite/db.js 中的方法 ===\n');
-        
-        // 初始化SQLite实例
-        sql = new Sqlite({
-            database: './db/test_db_methods.db'
-        });
-        
-        await sql.open();
-        console.log('✓ 数据库连接成功');
-        
-        // 获取数据库操作实例
-        const db = sql.db();
-        const test_table = 'test_db_methods';
-        const backup_table = 'test_db_methods_backup';
-        
-        // 清理测试环境
-        console.log('\n=== 1. 清理测试环境 ===');
-        await db.dropTable(test_table);
-        await db.dropTable(backup_table);
-        console.log('✓ 测试环境清理完成');
-        
-        // 2. 测试表操作方法
-        console.log('\n=== 2. 测试表操作方法 ===');
-        
-        // 测试addTable
-        console.log('测试addTable()方法...');
-        const createResult = await db.addTable(test_table, 'id', 'int', true, '测试表');
-        console.log('✓ 表创建结果:', createResult);
-        
-        // 测试hasTable
-        console.log('测试hasTable()方法...');
-        const hasTableResult = await db.hasTable(test_table);
-        console.log('✓ 表是否存在:', hasTableResult);
-        
-        // 测试tables
-        console.log('测试tables()方法...');
-        const tablesResult = await db.tables();
-        console.log('✓ 表列表:', tablesResult);
-        
-        // 3. 测试字段操作方法
-        console.log('\n=== 3. 测试字段操作方法 ===');
-        
-        // 设置表名
-        db.table = test_table;
-        
-        // 测试addField
-        console.log('测试addField()方法...');
-        const addFieldResult1 = await db.addField('username', 'varchar', '', true, false, '用户名');
-        console.log('✓ 添加username字段结果:', addFieldResult1);
-        
-        // 测试addField（添加email字段）
-        console.log('测试addField()方法（添加email字段）...');
-        const addFieldResult2 = await db.addField('email', 'varchar', '', true, false, '邮箱');
-        console.log('✓ 添加email字段结果:', addFieldResult2);
-        
-        // 测试addField（添加age字段）
-        console.log('测试addField()方法（添加age字段）...');
-        const addFieldResult3 = await db.addField('age', 'int', 0, true, false, '年龄');
-        console.log('✓ 添加age字段结果:', addFieldResult3);
-        
-        // 测试setField
-        console.log('测试setField()方法...');
-        const setFieldResult = await db.setField('email', 'varchar', '', true, false, '电子邮箱');
-        console.log('✓ 修改email字段结果:', setFieldResult);
-        
-        // 测试addField（添加temp字段用于后续delField测试）
-        console.log('测试addField()方法（添加temp字段）...');
-        await db.addField('temp', 'int', 0, false, false, '临时字段');
-        console.log('✓ 添加temp字段结果: 成功');
-        
-        // 测试fields
-        console.log('测试fields()方法...');
-        const fieldsResult = await db.fields();
-        console.log('✓ 字段信息:', fieldsResult.map(f => f.name));
-        
-        // 测试hasField
-        console.log('测试hasField()方法...');
-        const hasFieldResult = await db.hasField(test_table, 'username');
-        console.log('✓ username字段是否存在:', hasFieldResult);
-        
-        // 测试delField
-        console.log('测试delField()方法...');
-        const delFieldResult = await db.delField(test_table, 'temp');
-        console.log('✓ 删除temp字段结果:', delFieldResult);
-        
-        // 测试renameField
-        console.log('测试renameField()方法...');
-        try {
-            // 先检查当前字段
-            const fieldsBefore = await db.fields();
-            console.log('  - 重命名前字段:', fieldsBefore.map(f => f.name));
-            
-            const renameFieldResult = await db.renameField(test_table, 'age', 'user_age');
-            console.log('  - 重命名age字段结果:', renameFieldResult);
-            
-            // 检查重命名后字段
-            const fieldsAfter = await db.fields();
-            console.log('  - 重命名后字段:', fieldsAfter.map(f => f.name));
-            
-            // 只有当user_age字段存在时，才尝试重命名回age字段
-            const hasUserAgeField = fieldsAfter.some(f => f.name === 'user_age');
-            if (hasUserAgeField) {
-                // 重命名回age字段，保持后续测试一致
-                await db.renameField(test_table, 'user_age', 'age');
-                console.log('  - 重命名user_age字段回age结果: 成功');
-                
-                // 再次检查字段
-                const fieldsFinal = await db.fields();
-                console.log('  - 最终字段:', fieldsFinal.map(f => f.name));
-            } else {
-                console.warn('  - user_age字段不存在，跳过重命名回age字段');
-            }
-            
-            console.log('✓ renameField方法测试完成');
-        } catch (error) {
-            console.warn('⚠️  renameField()方法测试失败:', error.message);
-            console.log('⚠️  renameField()方法测试跳过');
-        }
-        
-        // 4. 测试数据操作方法
-        console.log('\n=== 4. 测试数据操作方法 ===');
-        
-        // 测试add（插入数据）
-        console.log('测试add()方法...');
-        const addResult = await db.add({
-            username: 'test_user',
-            email: 'test@example.com',
-            age: 25
-        });
-        console.log('✓ 插入数据结果:', addResult);
-        
-        // 测试get（查询单条数据）
-        console.log('测试get()方法...');
-        const getResult = await db.get({ id: 1 });
-        console.log('✓ 查询单条数据结果:', getResult[0]);
-        
-        // 测试get（查询多条数据）
-        console.log('测试get()方法（查询多条数据）...');
-        const listResult = await db.get();
-        console.log('✓ 查询多条数据结果:', listResult.length);
-        
-        // 测试set（更新数据）
-        console.log('测试set()方法...');
-        const setResult = await db.set({ id: 1 }, { age: 26 });
-        console.log('✓ 更新数据结果:', setResult);
-        
-        // 测试set（另一种查询条件更新方式）
-        console.log('测试set()方法（使用where属性）...');
-        db.where = { id: 1 };
-        const setResult2 = await db.set(db.where, { age: 27 });
-        console.log('✓ set方法（使用where属性）更新结果:', setResult2);
-        
-        // 测试del（删除数据）
-        console.log('测试del()方法...');
-        const delResult = await db.del({ id: 1 });
-        console.log('✓ 删除数据结果:', delResult);
-        
-        // 5. 测试事务操作方法
-        console.log('\n=== 5. 测试事务操作方法 ===');
-        
-        // 重新插入一条数据用于事务测试
-        await db.add({
-            username: 'transaction_test',
-            email: 'transaction@example.com',
-            age: 30
-        });
-        
-        try {
-            // 测试start（开始事务）
-            console.log('  - 事务开始');
-            await db.start();
-            
-            // 在事务中插入数据
-            await db.add({
-                username: 'transaction_user',
-                email: 'user@example.com',
-                age: 35
-            });
-            console.log('  - 事务中插入数据成功');
-            
-            // 测试commit（提交事务）
-            await db.commit();
-            console.log('  - 事务提交成功');
-            
-            // 验证事务提交结果
-            const transactionResult = await db.get();
-            console.log('  - 事务后数据总数:', transactionResult.length);
-            
-        } catch (error) {
-            // 测试back（回滚事务）
-            await db.back();
-            console.log('  - 事务回滚');
-            throw error;
-        } finally {
-            // 测试end（结束事务）
-            db.end();
-        }
-        console.log('✓ 事务操作完成');
-        
-        // 6. 测试其他方法
-        console.log('\n=== 6. 测试其他方法 ===');
-        
-        // 测试getCreateTable
-        console.log('测试getCreateTable()方法...');
-        const createTableResult = await db.getCreateTable(test_table);
-        console.log('✓ 表创建语句:', createTableResult);
-        
-        // 测试backupTable
-        console.log('测试backupTable()方法...');
-        const backupResult = await db.backupTable(test_table, backup_table);
-        console.log('✓ 表备份结果:', backupResult);
-        
-        // 测试hasTable（备份表）
-        console.log('测试hasTable()方法（备份表）...');
-        const hasBackupTableResult = await db.hasTable(backup_table);
-        console.log('✓ 备份表是否存在:', hasBackupTableResult);
-        
-        // 测试emptyTable
-        console.log('测试emptyTable()方法...');
-        const emptyResult = await db.emptyTable(test_table);
-        console.log('✓ 清空表结果:', emptyResult);
-        
-        // 7. 清理测试环境
-        console.log('\n=== 7. 清理测试环境 ===');
-        await db.dropTable(test_table);
-        await db.dropTable(backup_table);
-        console.log('✓ 测试环境清理完成');
-        
-        // 关闭数据库连接
-        console.log('\n=== 8. 关闭数据库连接 ===');
-        await sql.close();
-        console.log('✓ 数据库连接关闭成功');
-        
-        console.log('\n' + '='.repeat(50));
-        console.log('所有测试完成！db.js方法测试通过');
-        console.log('='.repeat(50));
-        
-    } catch (error) {
-        console.error('\n测试失败:', error.message);
-        // 关闭数据库连接
-        try {
-            if (sql) await sql.close();
-        } catch (closeError) {
-            console.error('关闭数据库连接失败:', closeError.message);
-        }
-        process.exit(1);
-    }
-}
-
-// 运行测试
-testDbMethods();
-
-setTimeout(() => {
-    process.exit(0);
-}, 5000);