mm_sqlite 1.0.6 → 1.0.8

package/index.js

@@ -1,224 +1,724 @@
-const resolve = require('path').resolve;
 const sqlite3 = require('sqlite3').verbose();
-const {
-	DB
-} = require('./db');
-
-const Link_model = require('./link_model');
-
-var pool = {};
-
-/// 数据库封装
-class Sqlite {
-	/**
-	 * @description 创建Redis帮助类函数 (构造函数)
-	 * @param {String} scope 作用域
-	 * @param {String} dir 当前路径
-	 * @constructor
-	 */
-	constructor(scope, dir) {
-		// 作用域
-		this.scope;
-		if (scope) {
-			this.scope = scope;
-		} else {
-			this.scope = $.val.scope + '';
-		}
-		// 当前目录
-		this.dir = __dirname;
-		if (dir) {
-			this.dir = dir;
-		}
-		// 错误提示
-		this.error;
-		/**
-		 * sql语句
-		 */
-		this.sql = "";
-		// 执行结果
-		this.results = [];
-		// 连接器
-		this.conn;
-
-		// 数据库配置参数
-		this.config = {
-			// 服务器地址
-			host: "./db/".fullname(this.dir),
-			// 数据库
-			database: "mm"
-		};
-
-		// 唯一标识符
-		this.identifier = resolve(this.config.host, this.config.database);
-
-		// 定义当前类, 用于数据库实例化访问
-		var $this = this;
-
-		/**
-		 * @description 查询sql
-		 * @param {String} sql 查询参
-		 * @param {Array} val 替换值
-		 * @return {Promise|Array} 异步构造器, 当await时返回执行结果
-		 */
-		this.run = function(sql, val) {
-			sql = sql.replaceAll("&&", "AND").replaceAll("||", "OR").replaceAll("varchar", "text").replaceAll(" int", " integer");
-			var _this = this;
-			this.sql = sql;
-			
-			// 返回一个 Promise
-			return new Promise((resolve, reject) => {
-				$this.conn.all(sql, val, function(err, rows) {
-					if (err) {
-						// reject(err);
-						_this.error = {
-							code: err.errno,
-							message: $.info(err).between('Error: ', ']')
-						};
-						resolve(rows || []);
-					} else {
-						_this.error = undefined;
-						resolve(rows || []);
-					}
-				});
-			});
-		};
-		
-		/**
-		 * @description 增删改sql
-		 * @param {String} sql 查询参
-		 * @param {Array} val 替换值
-		 * @return {Promise|Array} 异步构造器, 当await时返回执行结果
-		 */
-		this.exec = function(sql) {
-			sql = sql.replaceAll("&&", "AND").replaceAll("||", "OR").replaceAll("varchar", "text").replaceAll(" int", " integer");
-			var _this = this;
-			this.sql = sql;
-			// 返回一个 Promise
-			return new Promise((resolve, reject) => {
-				$this.conn.run(sql, function(err, rows) {
-					if (err) {
-						// reject(err);
-						_this.error = {
-							code: err.errno,
-							message: $.info(err).between('Error: ', ']')
-						};
-						resolve(0);
-					} else {
-						_this.error = undefined;
-						resolve(1);
-					}
-				});
-			});
-		};
-	
-		/**
-		 * @description 获取数据库管理器
-		 */
-		this.db = function() {
-			return new DB($this);
-		};
-	}
+const DB = require('./db');
+const { BaseService } = require('mm_base_service');
+
+/**
+ * SQLite数据库操作类
+ * @class Sqlite
+ * @extends BaseService
+ */
+class Sqlite extends BaseService {
+  /**
+   * 默认配置
+   */
+  static default_config = {
+    host: "/db/".fullname(),
+    port: 3306,
+    user: "root",
+    password: "",
+    database: "mm",
+    charset: "utf8mb4",
+    timezone: "+08:00",
+    connect_timeout: 20000,
+    acquire_timeout: 20000,
+    query_timeout: 20000,
+    connection_limit: 1,
+    queue_limit: 0,
+    enable_keep_alive: true,
+    keep_alive_initial_delay: 10000,
+    enable_reconnect: true,
+    reconnect_interval: 1000,
+    max_reconnect_attempts: 5,
+    wait_for_connections: true
+  };
+
+  /**
+   * 构造函数
+   * @param {Object} config - 配置对象
+   */
+  constructor(config) {
+    const merged_config = Object.assign({}, Sqlite.default_config, config || {});
+    super(merged_config);
+    
+    this.config = merged_config;
+    this._connection = null;
+    this._pool = null;
+    this._status = 'closed';
+    this._last_connect_time = 0;
+    this._reconnecting = false;
+    this._is_inited = false;
+    this._is_destroyed = false;
+    this._db = null;
+    this._open = false;
+    this._conn_retry_count = 0;
+  }
 }
 
 /**
- * 设置配置参数
- * @param {Object} cg 配置对象或配置路径
+ * 初始化服务
+ * @returns {Promise<void>}
  */
-Sqlite.prototype.setConfig = function(cg) {
-	var obj;
-	if (typeof(cg) === "string") {
-		obj = cg.loadJson(this.dir);
-	} else {
-		obj = cg;
-	}
-	$.push(this.config, obj);
-	this.identifier = resolve(this.config.host, this.config.database);
-};
-
-/**
- * @description 打开数据库, 如果没有则建立数据库连接再打开
- */
-Sqlite.prototype.open = function() {
-	if (!pool[this.identifier]) {
-		var file = resolve(this.config.host, this.config.database) + '.db';
-		var _this = this;
-		pool[this.identifier] = new sqlite3.Database(file, sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE,
-			function(err) {
-				if (err) {
-					_this.error = {
-						code: err.errno,
-						message: $.info(err).between('Error: ', ']')
-					};
-				} else {
-					_this.error = undefined;
-				}
-			});
-	}
-	this.conn = pool[this.identifier];
+Sqlite.prototype._initService = async function() {
+  if (this._is_inited) {
+    $.log.warn('SQLite服务已初始化');
+    return;
+  }
+
+  try {
+    $.log.debug('[Sqlite] [_initService]', '初始化SQLite服务', { config: this.config });
+    this._is_inited = true;
+    $.log.debug('[Sqlite] [_initService]', 'SQLite服务初始化完成');
+  } catch (error) {
+    $.log.error('[Sqlite] [_initService]', 'SQLite服务初始化失败', { error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * 打开数据库连接
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<boolean>}
+ */
+Sqlite.prototype.open = async function(timeout) {
+  if (this._status === 'connected' || this._status === 'connecting') {
+    $.log.warn('数据库连接已存在或正在连接中');
+    return true;
+  }
+
+  timeout = timeout || this.config.connect_timeout || 10000;
+  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) => {
+      setTimeout(() => {
+        reject(new Error(`数据库连接超时(${timeout}ms)`));
+      }, timeout);
+    });
+
+    try {
+      await Promise.race([connection_promise, timeout_promise]);
+
+      this._last_connect_time = Date.now();
+      this._status = 'connected';
+      $.log.info(`[${this.constructor.name}] [open]`, '数据库连接成功', {
+        host: this.config.host,
+        port: this.config.port,
+        database: this.config.database
+      });
+      return true;
+    } catch (connection_err) {
+      $.log.error(`[${this.constructor.name}] [open]`, '连接过程错误详情', {
+        error: connection_err.message,
+        code: connection_err.code,
+        syscall: connection_err.syscall,
+        address: connection_err.address,
+        port: connection_err.port,
+        stack: connection_err.stack
+      });
+      throw connection_err;
+    }
+  } catch (err) {
+    this._status = 'closed';
+    $.log.error(`[${this.constructor.name}] [open]`, '数据库连接失败', {
+      error: err.message,
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database
+    });
+    throw err;
+  }
+};
+
+/**
+ * 内部连接方法
+ * @private
+ * @returns {Promise<void>}
+ */
+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 });
+      }
+      
+      // 创建数据库连接
+      this._db = new sqlite3.Database(db_path);
+      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}`);
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
 };
 
 /**
- * @description 关闭连接
+ * 获取数据库路径
+ * @private
+ * @returns {String}
+ */
+Sqlite.prototype._getDatabasePath = function() {
+  const db_name = this.config.database || 'mm';
+  const db_dir = this.config.host || '/db/';
+  return `${db_dir}${db_name}.db`;
+};
+
+/**
+ * 关闭数据库连接
+ * @returns {Promise<boolean>}
  */
 Sqlite.prototype.close = function() {
-	if (pool[this.identifier]) {
-		pool[this.identifier].close();
-		pool[this.identifier] = null;
-	}
+  if (this._status !== 'connected') {
+    $.log.warn('数据库连接未建立');
+    return Promise.resolve(false);
+  }
+
+  return new Promise((resolve) => {
+    try {
+      if (this._db) {
+        $.log.debug('关闭数据库连接');
+        this._db.close((err) => {
+          if (err) {
+            $.log.error('关闭数据库失败', { error: err.message });
+          } else {
+            $.log.info('数据库已关闭');
+          }
+          this._db = null;
+          this._open = false;
+          this._status = 'closed';
+          resolve(!err);
+        });
+      } else {
+        this._status = 'closed';
+        resolve(true);
+      }
+    } catch (err) {
+      $.log.error('关闭数据库连接时发生异常', { error: err.message });
+      this._status = 'closed';
+      resolve(false);
+    }
+  });
 };
 
 /**
- * 获取数据库管理器
- * @param {String} key 主键
- * @param {String|Number} value 对象值 
- * @param {Boolean} clear_prefix 清除前缀
- * @param {Array} arr_table 关联的数据表
- * @return {Object} 管理模型
+ * 获取数据库连接
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
  */
-Sqlite.prototype.dbs = async function(key, value, clear_prefix, ...arr_table) {
-	var lm = new Link_model({
-		key,
-		value,
-		clear_prefix
-	});
-	lm.sql = this;
-	for (var i = 0; i < arr_table.length; i++) {
-		await lm.add(arr_table[i]);
-	}
-	return lm;
+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`);
+
+  if (this._status !== 'connected') {
+    throw new Error('数据库连接未建立');
+  }
+
+  try {
+    const connection_promise = new Promise((resolve) => {
+      resolve(this._db);
+    });
+    const timeout_promise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`获取数据库连接超时(${timeout}ms)`));
+      }, timeout);
+    });
+
+    const conn = await Promise.race([connection_promise, timeout_promise]);
+
+    // $.log.debug(`[${this.constructor.name}] [getConn] 成功获取数据库连接`);
+
+    // 处理连接错误
+    conn.on('error', (err) => {
+      if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+        this._handleConnectionError(err);
+      }
+    });
+
+    return conn;
+  } catch (error) {
+    $.log.error(`[${this.constructor.name}] [getConn] 获取连接失败`, {
+      error: error.message
+    });
+
+    if (error.code && (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(error);
+    }
+
+    throw error;
+  }
 };
 
 /**
- * @description 导出Sqlite帮助类
+ * 处理连接错误
+ * @private
+ * @param {Error} err - 错误对象
  */
-exports.Sqlite = Sqlite;
+Sqlite.prototype._handleConnectionError = function(err) {
+  if (this._reconnecting) {
+    $.log.debug('重连已在进行中');
+    return;
+  }
+
+  if (this.config.enable_reconnect) {
+    $.log.info('开始自动重连...');
+    this._reconnect(this.config.max_reconnect_attempts || 3)
+      .catch(reconnect_err => {
+        $.log.error('重连失败', { error: reconnect_err.message });
+        this._status = 'closed';
+      });
+  } else {
+    $.log.warn('自动重连已禁用');
+    this._status = 'closed';
+  }
+};
 
 /**
- * @description sqlite连接池
+ * 重新连接数据库
+ * @private
+ * @param {Number} max_retries - 最大重试次数
+ * @returns {Promise<boolean>}
  */
+Sqlite.prototype._reconnect = async function(max_retries) {
+  if (this._reconnecting) {
+    $.log.warn('重连已在进行中');
+    return false;
+  }
+
+  this._reconnecting = true;
+  let retry_count = 0;
+
+  try {
+    // 先关闭现有连接
+    if (this._status === 'connected') {
+      await this.close();
+    }
+
+    while (retry_count < max_retries) {
+      retry_count++;
+      $.log.info(`第${retry_count}/${max_retries}次尝试重连`);
+
+      try {
+        const reconnect_timeout = this.config.connect_timeout || this.config.acquire_timeout || 20000;
+        $.log.debug(`重连超时设置为: ${reconnect_timeout}ms`);
+        await this.open(reconnect_timeout);
+        $.log.info('重连成功');
+        return true;
+      } catch (err) {
+        $.log.error(`重连失败(${retry_count}/${max_retries})`, { error: err.message });
+
+        if (retry_count < max_retries) {
+          const wait_time = this.config.reconnect_interval || 1000;
+          $.log.debug(`等待${wait_time}ms后重试`);
+          await this._sleep(wait_time);
+        }
+      }
+    }
+
+    $.log.error(`达到最大重试次数(${max_retries})，重连失败`);
+    throw new Error(`重连失败：达到最大重试次数(${max_retries})`);
+  } finally {
+    this._reconnecting = false;
+  }
+};
+
+/**
+ * 休眠函数
+ * @private
+ * @param {Number} ms - 休眠时间(毫秒)
+ * @returns {Promise<void>}
+ */
+Sqlite.prototype._sleep = function(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+/**
+ * 执行SQL查询
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
+ */
+Sqlite.prototype.run = async function(sql, params, timeout) {
+  let conn = null;
+  timeout = timeout || this.config.query_timeout || 30000;
+
+  try {
+    // 获取连接
+    conn = await this.getConn(timeout);
+
+    // 直接在方法内部实现超时控制
+    const query_promise = new Promise((resolve, reject) => {
+      conn.all(sql, params || [], (error, rows) => {
+        if (error) {
+          reject(error);
+        } else {
+          // 保持与MySQL兼容的返回值格式
+          // 如果是SELECT查询且只有一行结果，返回第一行
+          // 否则返回完整结果数组
+          if (sql.trim().toUpperCase().startsWith('SELECT') && rows.length === 1) {
+            resolve(rows[0]);
+          } else {
+            resolve(rows);
+          }
+        }
+      });
+    });
+    
+    const timeout_promise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`SQL查询超时: ${timeout}ms`));
+      }, timeout);
+    });
+
+    const result = await Promise.race([query_promise, timeout_promise]);
+
+    return result;
+  } catch (err) {
+    $.log.error('[Sqlite] [run]', 'SQL执行失败', {
+      error: err.message,
+      sql: typeof sql === 'string' ? sql.substring(0, 200) : sql,
+      params: params
+    });
+
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(err);
+    }
+
+    throw err;
+  }
+};
+
+/**
+ * 执行SQL语句（用于执行非查询语句如INSERT/UPDATE/DELETE）
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
+ */
+Sqlite.prototype.exec = async function(sql, params, timeout) {
+  let conn = null;
+  timeout = timeout || this.config.query_timeout || 30000;
+
+  try {
+    // 获取连接
+    conn = await this.getConn(timeout);
+
+    // 直接在方法内部实现超时控制
+    const query_promise = new Promise((resolve, reject) => {
+      conn.run(sql, params || [], function(error) {
+        if (error) {
+          reject(error);
+        } else {
+          // 保持与MySQL兼容的返回值格式
+          resolve({
+            affected_rows: this.changes || 0,
+            insert_id: this.lastID || 0,
+            changed_rows: this.changes || 0
+          });
+        }
+      });
+    });
+    
+    const timeout_promise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`SQL执行超时: ${timeout}ms`));
+      }, timeout);
+    });
+
+    const result = await Promise.race([query_promise, timeout_promise]);
+
+    return result;
+  } catch (err) {
+    $.log.error('[Sqlite] [exec]', 'SQL执行失败', {
+      error: err.message,
+      sql: sql.substring(0, 200),
+      params: params
+    });
+
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(err);
+    }
+
+    throw err;
+  }
+};
+
+/**
+ * 读取整张表的数据
+ * @param {String} table - 表名
+ * @param {Object} condition - 查询条件
+ * @param {Object} options - 选项（order_by, limit, offset等）
+ * @returns {Promise<Array>}
+ */
+Sqlite.prototype.read = async function(table, condition, options) {
+  try {
+    // 检查连接状态
+    if (this._status !== 'connected') {
+      throw new Error('数据库连接未建立');
+    }
+
+    // 构建基础SQL查询
+    let sql = `SELECT * FROM ${table}`;
+    const params = [];
+
+    // 处理条件
+    if (condition && Object.keys(condition).length > 0) {
+      const where_clauses = [];
+      for (const [field, value] of Object.entries(condition)) {
+        where_clauses.push(`${field} = ?`);
+        params.push(value);
+      }
+      sql += ` WHERE ${where_clauses.join(' AND ')}`;
+    }
+
+    // 处理排序
+    if (options && options.order_by) {
+      sql += ` ORDER BY ${options.order_by}`;
+    }
+
+    // 处理分页
+    if (options && options.limit) {
+      sql += ` LIMIT ${options.limit}`;
+    }
+
+    if (options && options.offset) {
+      sql += ` OFFSET ${options.offset}`;
+    }
+
+    // 记录查询日志
+    if (this.config.debug) {
+      $.log.debug(`[${this.constructor.name}] [read] 查询数据`, { sql, params });
+    }
+
+    // 执行查询
+    const results = await this.run(sql, params);
+
+    if (this.config.debug) {
+      $.log.info(`[${this.constructor.name}] [read] 查询成功`, { count: Array.isArray(results) ? results.length : 1 });
+    }
+
+    // 确保返回数组格式
+    return Array.isArray(results) ? results : [results];
+  } catch (error) {
+    // 记录错误日志
+    $.log.error(`[${this.constructor.name}] [read] 查询失败`, {
+      error: error.message,
+      table: table,
+      condition: condition
+    });
+
+    // 抛出错误
+    throw error;
+  }
+};
+
+/**
+ * 获取数据库操作实例
+ * @param {String} database - 数据库名称
+ * @returns {Object} 数据库操作实例
+ */
+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;
+};
+
+/**
+ * 获取数据库管理器模型
+ * @returns {Object} 数据库管理器模型
+ */
+Sqlite.prototype.dbs = function() {
+  return this.db();
+};
+
+/**
+ * 开始事务
+ * @returns {Promise<Object>} 事务连接对象
+ */
+Sqlite.prototype.beginTransaction = async function() {
+  try {
+    // 检查连接状态
+    if (this._status !== 'connected') {
+      throw new Error('数据库连接未建立');
+    }
+
+    // 获取连接
+    const connection = await this.getConn();
+
+    // 开始事务
+    await new Promise((resolve, reject) => {
+      connection.run('BEGIN TRANSACTION', (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    if (this.config.debug) {
+      $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务开始`);
+    }
+
+    // 返回事务连接对象，包含提交和回滚方法
+    return {
+      connection,
+      commit: async () => {
+        await new Promise((resolve, reject) => {
+          connection.run('COMMIT', (error) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
+            }
+          });
+        });
+        if (this.config.debug) {
+          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务提交`);
+        }
+      },
+      rollback: async () => {
+        await new Promise((resolve, reject) => {
+          connection.run('ROLLBACK', (error) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
+            }
+          });
+        });
+        if (this.config.debug) {
+          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务回滚`);
+        }
+      },
+      exec: async (sql, params) => {
+        // 在事务中执行SQL
+        return new Promise((resolve, reject) => {
+          connection.run(sql, params || [], function(error) {
+            if (error) {
+              reject(error);
+            } else {
+              resolve({
+                affected_rows: this.changes,
+                insert_id: this.lastID,
+                changed_rows: this.changes,
+                last_id: this.lastID,
+                changes: this.changes
+              });
+            }
+          });
+        });
+      }
+    };
+  } catch (error) {
+    $.log.error(`[${this.constructor.name}] [beginTransaction] 事务开始失败`, { error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * 在事务中执行多个操作
+ * @param {Function} callback - 包含事务操作的回调函数
+ * @returns {Promise<*>} 回调函数的返回值
+ */
+Sqlite.prototype.transaction = async function(callback) {
+  let transaction = null;
+
+  try {
+    // 开始事务
+    transaction = await this.beginTransaction();
+
+    // 执行回调函数，传入事务对象
+    const result = await callback(transaction);
+
+    // 提交事务
+    await transaction.commit();
+
+    return result;
+  } catch (error) {
+    // 如果有事务，回滚
+    if (transaction) {
+      await transaction.rollback().catch(err => {
+        $.log.error(`[${this.constructor.name}] [transaction] 事务回滚失败`, { error: err.message });
+      });
+    }
+
+    $.log.error(`[${this.constructor.name}] [transaction] 事务执行失败`, { error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+	$.pool = {};
+}
 if (!$.pool.sqlite) {
 	$.pool.sqlite = {};
 }
 
 /**
- * @description 缓存管理器，用于创建缓存
+ * Sqlite管理器，用于创建缓存
  * @param {String} scope 作用域
- * @param {String} dir 当前路径
- * @return {Object} 返回一个缓存类
+ * @param {Object} config 配置参数
+ * @return {Object} 返回一个Sqlite类实例
  */
-function sqlite_admin(scope, dir) {
+function sqliteAdmin(scope, config) {
 	if (!scope) {
-		scope = $.val.scope
+		scope = 'sys';
 	}
 	var obj = $.pool.sqlite[scope];
 	if (!obj) {
-		$.pool.sqlite[scope] = new Sqlite(scope, dir);
+		$.pool.sqlite[scope] = new Sqlite(config);
 		obj = $.pool.sqlite[scope];
 	}
 	return obj;
 }
 
-/**
- * @description 导出Sqlite管理函数
- */
-exports.sqlite_admin = sqlite_admin;
+// 模块导出
+exports.Sqlite = Sqlite;
+exports.sqliteAdmin = sqliteAdmin;