mm_cachebase 1.4.6 → 1.5.0

package/index.js

@@ -1,7 +1,7 @@
 require('mm_logs');
 const EventEmitter = require('events');
 
-// 简化版的CacheBase类，只包含事件触发核心功能
+// 符合Redis API的CacheBase类
 class CacheBase extends EventEmitter {
   constructor() {
     super();
@@ -24,7 +24,7 @@ class CacheBase extends EventEmitter {
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(null);
+          resolve(0);
           return;
         }
 
@@ -40,9 +40,9 @@ class CacheBase extends EventEmitter {
         this.emit('set_after', { 
           key, 
           value, 
-          result: 1 
+          result: 'OK' 
         });
-        resolve(1);
+        resolve('OK');
       } catch (error) {
         // 触发错误事件
         this.emit('set_error', { 
@@ -146,7 +146,156 @@ class CacheBase extends EventEmitter {
     });
   }
 
-  // 哈希表设置方法
+  // Redis兼容的getset方法
+  async getset(key, value) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key, 
+          value,
+          cancel: false 
+        };
+        this.emit('getset_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(null);
+          return;
+        }
+
+        // 获取旧值
+        const obj = this.data[key];
+        const oldValue = obj ? obj.value : null;
+        
+        // 设置新值
+        this.data[key] = { value, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('getset_after', { 
+          key, 
+          value,
+          result: oldValue 
+        });
+        resolve(oldValue);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('getset_error', { 
+          key, 
+          value,
+          error 
+        });
+        $.log.error('[cachebase] getset操作失败:', error);
+        resolve(null);
+      }
+    });
+  }
+
+  // Redis兼容的append方法
+  async append(key, value) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key, 
+          value,
+          cancel: false 
+        };
+        this.emit('append_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 获取当前值或默认为空字符串
+        const obj = this.data[key];
+        let currentValue = '';
+        if (obj) {
+          currentValue = String(obj.value);
+        }
+        
+        // 执行字符串拼接
+        const newValue = currentValue + String(value);
+        const result = newValue.length;
+        
+        // 保存结果
+        this.data[key] = { value: newValue, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
+        }
+
+        // 触发后置事件
+        this.emit('append_after', { 
+          key, 
+          value,
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('append_error', { 
+          key, 
+          value,
+          error 
+        });
+        $.log.error('[cachebase] append操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // Redis兼容的strlen方法
+  async strlen(key) {
+    return new Promise((resolve) => {
+      try {
+        // 触发前置事件
+        const beforeEventData = { 
+          key,
+          cancel: false 
+        };
+        this.emit('strlen_before', beforeEventData);
+
+        // 如果事件处理器设置了cancel为true，则取消操作
+        if (beforeEventData.cancel) {
+          resolve(0);
+          return;
+        }
+
+        // 执行实际操作
+        const obj = this.data[key];
+        let result = 0;
+        if (obj) {
+          result = String(obj.value).length;
+        }
+
+        // 触发后置事件
+        this.emit('strlen_after', { 
+          key,
+          result 
+        });
+        resolve(result);
+      } catch (error) {
+        // 触发错误事件
+        this.emit('strlen_error', { 
+          key,
+          error 
+        });
+        $.log.error('[cachebase] strlen操作失败:', error);
+        resolve(0);
+      }
+    });
+  }
+
+  // 哈希表设置方法 - 模拟实现
   async hset(key, field, value) {
     return new Promise((resolve) => {
       try {
@@ -201,129 +350,104 @@ class CacheBase extends EventEmitter {
     });
   }
 
-  // 列表头部推入方法
-  async lpush(key, ...values) {
+  // 哈希表获取字段值方法 - 模拟实现
+  async hget(key, field) {
     return new Promise((resolve) => {
       try {
-        // 触发前置事件，将values作为value的一部分
+        // 触发前置事件
         const beforeEventData = { 
           key, 
-          value: { values }, 
+          value: { field }, 
           cancel: false 
         };
-        this.emit('lpush_before', beforeEventData);
+        this.emit('hget_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(0);
+          resolve(null);
           return;
         }
 
-        // 确保列表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: [], expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!Array.isArray(this.data[key].value)) {
-          this.data[key].value = [];
+        // 执行实际操作
+        const obj = this.data[key];
+        let result = null;
+        if (obj && typeof obj.value === 'object' && field in obj.value) {
+          result = obj.value[field];
         }
 
-        // 将值添加到列表头部
-        this.data[key].value.unshift(...values);
-
         // 触发后置事件
-        this.emit('lpush_after', { 
+        this.emit('hget_after', { 
           key, 
-          value: { values }, 
-          result: this.data[key].value.length 
+          value: { field }, 
+          result 
         });
-        resolve(this.data[key].value.length);
+        resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('lpush_error', { 
+        this.emit('hget_error', { 
           key, 
-          value: { values }, 
+          value: { field }, 
           error 
         });
-        $.log.error('[cachebase] lpush操作失败:', error);
-        resolve(0);
+        $.log.error('[cachebase] hget操作失败:', error);
+        resolve(null);
       }
     });
   }
 
-  // 集合添加方法
-  async sadd(key, ...members) {
+  // 哈希表获取所有字段和值方法 - 模拟实现
+  async hgetall(key) {
     return new Promise((resolve) => {
       try {
-        // 触发前置事件，将members作为value的一部分
+        // 触发前置事件
         const beforeEventData = { 
           key, 
-          value: { members }, 
           cancel: false 
         };
-        this.emit('sadd_before', beforeEventData);
+        this.emit('hgetall_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(0);
+          resolve({});
           return;
         }
 
-        // 确保集合存在
-        if (!this.data[key]) {
-          this.data[key] = { value: new Set(), expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!(this.data[key].value instanceof Set)) {
-          this.data[key].value = new Set();
+        // 执行实际操作
+        const obj = this.data[key];
+        let result = {};
+        if (obj && typeof obj.value === 'object') {
+          result = {...obj.value};
         }
 
-        // 记录添加前的大小
-        const beforeSize = this.data[key].value.size;
-        
-        // 添加成员
-        members.forEach(member => {
-          this.data[key].value.add(member);
-        });
-
-        // 计算新增的成员数
-        const addedCount = this.data[key].value.size - beforeSize;
-
         // 触发后置事件
-        this.emit('sadd_after', { 
+        this.emit('hgetall_after', { 
           key, 
-          value: { members }, 
-          result: addedCount 
+          result 
         });
-        resolve(addedCount);
+        resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('sadd_error', { 
+        this.emit('hgetall_error', { 
           key, 
-          value: { members }, 
           error 
         });
-        $.log.error('[cachebase] sadd操作失败:', error);
-        resolve(0);
+        $.log.error('[cachebase] hgetall操作失败:', error);
+        resolve({});
       }
     });
   }
 
-  // 有序集合添加方法
-  async zadd(key, ...args) {
+  // 哈希表删除字段方法 - 模拟实现
+  async hdel(key, field) {
     return new Promise((resolve) => {
       try {
-        // 触发前置事件，将args作为value的一部分
+        // 触发前置事件
         const beforeEventData = { 
           key, 
-          value: { args }, 
+          value: { field }, 
           cancel: false 
         };
-        this.emit('zadd_before', beforeEventData);
+        this.emit('hdel_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
@@ -331,59 +455,43 @@ class CacheBase extends EventEmitter {
           return;
         }
 
-        // 确保有序集合存在
-        if (!this.data[key]) {
-          this.data[key] = { value: { members: {}, sorted: [] }, expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!this.data[key].value || !this.data[key].value.members) {
-          this.data[key].value = { members: {}, sorted: [] };
-        }
-
-        let addedCount = 0;
-        
-        // 处理参数并添加成员
-        for (let i = 0; i < args.length; i += 2) {
-          const score = parseFloat(args[i]);
-          const member = args[i + 1];
-          
-          // 如果成员不存在，则计数增加
-          if (!this.data[key].value.members.hasOwnProperty(member)) {
-            addedCount++;
+        // 执行实际操作
+        let result = 0;
+        const obj = this.data[key];
+        if (obj && typeof obj.value === 'object' && field in obj.value) {
+          delete obj.value[field];
+          // 如果哈希表变空了，删除整个键
+          if (Object.keys(obj.value).length === 0) {
+            delete this.data[key];
+            const index = this.list.indexOf(key);
+            if (index > -1) {
+              this.list.splice(index, 1);
+            }
           }
-          
-          // 设置成员分数
-          this.data[key].value.members[member] = score;
+          result = 1;
         }
 
-        // 更新排序
-        this.data[key].value.sorted = Object.entries(this.data[key].value.members)
-          .sort((a, b) => a[1] - b[1])
-          .map(entry => entry[0]);
-
         // 触发后置事件
-        this.emit('zadd_after', { 
+        this.emit('hdel_after', { 
           key, 
-          value: { args }, 
-          result: addedCount 
+          value: { field }, 
+          result 
         });
-        resolve(addedCount);
+        resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('zadd_error', { 
+        this.emit('hdel_error', { 
           key, 
-          value: { args }, 
+          value: { field }, 
           error 
         });
-        $.log.error('[cachebase] zadd操作失败:', error);
+        $.log.error('[cachebase] hdel操作失败:', error);
         resolve(0);
       }
     });
   }
 
-  // 修复的mset方法
+  // 修复的mset方法 - Redis兼容格式
   async mset(...args) {
     return new Promise((resolve) => {
       try {
@@ -396,13 +504,13 @@ class CacheBase extends EventEmitter {
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve('');
+          resolve(null);
           return;
         }
 
         // 参数校验
         if (args.length % 2 !== 0) {
-          $.log.error('[cachebase] [cachebase] mset参数数量不正确');
+          $.log.error('[cachebase] mset参数数量不正确');
           resolve('ERR');
           return;
         }
@@ -436,71 +544,57 @@ class CacheBase extends EventEmitter {
     });
   }
 
-  // 浮点数加法方法
-  async addFloat(key, value) {
+  // 修复的mget方法 - 返回数组格式，与Redis保持一致
+  async mget(...keys) {
     return new Promise((resolve) => {
       try {
-        // 触发前置事件，将value作为浮点数
+        // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value: parseFloat(value), 
+          value: { keys }, 
           cancel: false 
         };
-        this.emit('addFloat_before', beforeEventData);
+        this.emit('mget_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(0);
+          resolve([]);
           return;
         }
 
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && typeof this.data[key].value === 'number') {
-          currentValue = this.data[key].value;
-        }
-
-        // 执行加法
-        const result = currentValue + parseFloat(value);
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
+        // 执行实际操作 - 返回数组格式，与Redis保持一致
+        const result = keys.map(key => {
+          const obj = this.data[key];
+          return obj ? obj.value : null;
+        });
 
         // 触发后置事件
-        this.emit('addFloat_after', { 
-          key, 
-          value: parseFloat(value), 
+        this.emit('mget_after', { 
+          value: { keys }, 
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('addFloat_error', { 
-          key, 
-          value: parseFloat(value), 
+        this.emit('mget_error', { 
+          value: { keys }, 
           error 
         });
-        $.log.error('[cachebase] addFloat操作失败:', error);
-        resolve(0);
+        $.log.error('[cachebase] mget操作失败:', error);
+        resolve([]);
       }
     });
   }
 
-  // 字符串添加方法
-  async addStr(key, value) {
+  // Redis兼容的exists方法，支持多个键
+  async exists(...keys) {
     return new Promise((resolve) => {
       try {
-        // 触发前置事件，将value作为字符串
+        // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value: String(value), 
+          value: { keys }, 
           cancel: false 
         };
-        this.emit('addStr_before', beforeEventData);
+        this.emit('exists_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
@@ -508,1118 +602,139 @@ class CacheBase extends EventEmitter {
           return;
         }
 
-        // 获取当前值或默认为空字符串
-        let currentValue = '';
-        if (this.data[key] && typeof this.data[key].value === 'string') {
-          currentValue = this.data[key].value;
-        }
-
-        // 执行字符串拼接
-        const result = currentValue + value;
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
+        // 执行实际操作
+        const result = keys.filter(key => key in this.data).length;
 
         // 触发后置事件
-        this.emit('addStr_after', { 
-          key, 
-          value: String(value), 
+        this.emit('exists_after', { 
+          value: { keys }, 
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('addStr_error', { 
-          key, 
-          value: String(value), 
+        this.emit('exists_error', { 
+          value: { keys }, 
           error 
         });
-        $.log.error('[cachebase] addStr操作失败:', error);
+        $.log.error('[cachebase] exists操作失败:', error);
         resolve(0);
       }
     });
   }
 
-  // 整数加法方法
-  async add(key, value) {
+  // 查询/设置过期时间方法，包含事件触发
+  async ttl(key) {
     return new Promise((resolve) => {
       try {
-        // 触发前置事件，将value作为整数
+        // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value: parseInt(value, 10), 
+          key,
           cancel: false 
         };
-        this.emit('add_before', beforeEventData);
+        this.emit('ttl_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && typeof this.data[key].value === 'number') {
-          currentValue = this.data[key].value;
-        }
-
-        // 执行整数加法
-        const result = currentValue + parseInt(value, 10);
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('add_after', { 
-          key, 
-          value: parseInt(value, 10), 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('add_error', { 
-          key, 
-          value: parseInt(value, 10), 
-          error 
-        });
-        $.log.error('[cachebase] add操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 列表设置方法 - 修改为兼容test.js
-  async list_set(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('list_set_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保值是数组
-        if (!Array.isArray(value)) {
-          this.emit('list_set_error', { 
-            key, 
-            value, 
-            error: new Error('值必须是数组') 
-          });
-          resolve(0);
-          return;
-        }
-
-        // 设置数组
-        this.data[key] = { value, expire: 0 };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('list_set_after', { 
-          key, 
-          value, 
-          result: 1 
-        });
-        resolve(1);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_set_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] list_set操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 列表添加元素方法
-  async list_add(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('list_add_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保列表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: [], expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!Array.isArray(this.data[key].value)) {
-          this.data[key].value = [];
-        }
-
-        // 添加元素到列表末尾
-        this.data[key].value.push(value);
-
-        // 触发后置事件
-        this.emit('list_add_after', { 
-          key, 
-          value, 
-          result: this.data[key].value.length 
-        });
-        resolve(this.data[key].value.length);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_add_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] list_add操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 列表清空方法
-  async list_clear(key, newValue) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('list_clear_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 检查键是否存在且值为数组
-        if (this.data[key] && Array.isArray(this.data[key].value)) {
-          // 如果提供了新值且是数组，则替换
-          if (newValue && Array.isArray(newValue)) {
-            this.data[key].value = newValue;
-          } else {
-            // 否则清空数组
-            this.data[key].value = [];
-          }
-          
-          // 触发后置事件
-          this.emit('list_clear_after', { 
-            key, 
-            result: 1 
-          });
-          resolve(1);
-        } else {
-          // 键不存在或值不是数组，如果提供了新值，则设置
-          if (newValue && Array.isArray(newValue)) {
-            this.data[key] = { value: newValue, expire: 0 };
-            // 添加到列表
-            if (!this.list.includes(key)) {
-              this.list.push(key);
-            }
-            this.emit('list_clear_after', { 
-              key, 
-              result: 1 
-            });
-            resolve(1);
-          } else {
-            this.emit('list_clear_after', { 
-              key, 
-              result: 0 
-            });
-            resolve(0);
-          }
-        }
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_clear_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] list_clear操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 仅当键不存在时设置值方法
-  async setnx(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('setnx_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 检查键是否不存在
-        if (!this.data.hasOwnProperty(key)) {
-          // 设置值
-          this.data[key] = { value, expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-          
-          // 触发后置事件
-          this.emit('setnx_after', { 
-            key, 
-            value, 
-            result: 1 
-          });
-          resolve(1);
-        } else {
-          // 键已存在
-          this.emit('setnx_after', { 
-            key, 
-            value, 
-            result: 0 
-          });
-          resolve(0);
-        }
-      } catch (error) {
-        // 触发错误事件
-        this.emit('setnx_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] setnx操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 设置带过期时间的键值对方法
-  async setex(key, seconds, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，使用ttl替代seconds
-        const beforeEventData = { 
-          key, 
-          value, 
-          ttl: parseInt(seconds, 10), 
-          cancel: false 
-        };
-        this.emit('setex_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 计算过期时间
-        const expireTime = Date.now() + (parseInt(seconds, 10) * 1000);
-        
-        // 设置值和过期时间
-        this.data[key] = { value, expire: expireTime };
-        // 添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件，使用ttl替代seconds
-        this.emit('setex_after', { 
-          key, 
-          value, 
-          ttl: parseInt(seconds, 10), 
-          result: "OK" 
-        });
-        resolve("OK");
-      } catch (error) {
-        // 触发错误事件，使用ttl替代seconds
-        this.emit('setex_error', { 
-          key, 
-          value, 
-          ttl: parseInt(seconds, 10), 
-          error 
-        });
-        $.log.error('[cachebase] setex操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 修复的setrange方法
-  async setrange(key, index, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将index和value作为value的一部分
-        const beforeEventData = { 
-          key, 
-          value: { index, value }, 
-          cancel: false 
-        };
-        this.emit('setrange_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve('ERR');
-          return;
-        }
-
-        const obj = this.data[key];
-        if (obj) {
-          // 确保值为字符串类型
-          let val = String(obj.value || '');
-          index = Math.max(0, parseInt(index) || 0);
-
-          // 处理index超出字符串长度的情况
-          if (index > val.length) {
-            // 填充空白字符
-            val = val.padEnd(index, '');
-          }
-
-          const start = val.substring(0, index);
-          const end = val.substring(index, val.length);
-          obj.value = start + value + end;
-
-          // 触发后置事件
-          this.emit('setrange_after', { 
-            key, 
-            value: { index, value }, 
-            result: obj.value.length 
-          });
-          resolve(obj.value.length);
-        } else {
-          resolve('ERR');
-        }
-      } catch (error) {
-        // 触发错误事件
-        this.emit('setrange_error', { 
-          key, 
-          value: { index, value }, 
-          error 
-        });
-        $.log.error('[cachebase] setrange操作失败:', error);
-        resolve('ERR');
-      }
-    });
-  }
-
-  // 新增：列表获取方法，包含事件触发
-  async list_get(key, start = 0, end = -1) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { start, end }, 
-          cancel: false 
-        };
-        this.emit('list_get_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = [];
-        if (obj && Array.isArray(obj.value)) {
-          if (end === -1) {
-            result = obj.value.slice(start);
-          } else {
-            result = obj.value.slice(start, end + 1);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('list_get_after', { 
-          key, 
-          value: { start, end }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_get_error', { 
-          key, 
-          value: { start, end }, 
-          error 
-        });
-        $.log.error('[cachebase] list_get操作失败:', error);
-        resolve([]);
-      }
-    });
-  }
-
-  // 新增：字符串范围获取方法，包含事件触发
-  async getrange(key, start, end) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { start, end }, 
-          cancel: false 
-        };
-        this.emit('getrange_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve('');
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = '';
-        if (obj && typeof obj.value === 'string') {
-          // 处理负数索引
-          if (start < 0) start = Math.max(0, obj.value.length + start);
-          if (end < 0) end = Math.max(0, obj.value.length + end);
-          
-          // 确保索引在有效范围内
-          start = Math.max(0, start);
-          end = Math.min(obj.value.length - 1, end);
-          
-          if (start <= end) {
-            result = obj.value.substring(start, end + 1);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('getrange_after', { 
-          key, 
-          value: { start, end }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('getrange_error', { 
-          key, 
-          value: { start, end }, 
-          error 
-        });
-        $.log.error('[cachebase] getrange操作失败:', error);
-        resolve('');
-      }
-    });
-  }
-
-  // 新增：列表包含检查方法，包含事件触发
-  async list_has(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('list_has_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = 0;
-        if (obj && Array.isArray(obj.value)) {
-          result = obj.value.includes(value) ? 1 : 0;
-        }
-
-        // 触发后置事件
-        this.emit('list_has_after', { 
-          key, 
-          value, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('list_has_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] list_has操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 检查键是否存在方法，包含事件触发
-  async exists(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('exists_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const result = key in this.data ? 1 : 0;
-
-        // 触发后置事件
-        this.emit('exists_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('exists_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] exists操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 检查键是否存在的别名方法，包含事件触发
-  async has(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('has_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const result = key in this.data ? 1 : 0;
-
-        // 触发后置事件
-        this.emit('has_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('has_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] has操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 查询/设置过期时间方法，包含事件触发
-  async ttl(key, maxAge) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: maxAge !== undefined ? { ttl: maxAge } : undefined,
-          cancel: false 
-        };
-        this.emit('ttl_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(maxAge !== undefined ? 0 : -2);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result;
-        
-        if (!obj) {
-          result = -2; // 键不存在
-        } else if (maxAge !== undefined) {
-          // 设置过期时间
-          if (maxAge === -1) {
-            obj.expire = 0; // 永不过期
-          } else {
-            obj.expire = Date.now() + (parseInt(maxAge, 10) * 1000);
-          }
-          result = 1;
-        } else {
-          // 查询过期时间
-          if (obj.expire === 0) {
-            result = -1; // 永不过期
-          } else {
-            const remaining = Math.floor((obj.expire - Date.now()) / 1000);
-            result = remaining > 0 ? remaining : -2; // -2表示已过期
-          }
-        }
-
-        // 触发后置事件
-        this.emit('ttl_after', { 
-          key, 
-          value: maxAge !== undefined ? { ttl: maxAge } : undefined,
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('ttl_error', { 
-          key, 
-          value: maxAge !== undefined ? { ttl: maxAge } : undefined,
-          error 
-        });
-        $.log.error('[cachebase] ttl操作失败:', error);
-        resolve(-2);
-      }
-    });
-  }
-
-  // 获取所有匹配键方法，包含事件触发
-  async keys(pattern) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          value: { pattern }, 
-          cancel: false 
-        };
-        this.emit('keys_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result;
-        if (!pattern || pattern === '*') {
-          result = [...this.list];
-        } else {
-          // 转换模式为正则表达式
-          const regexPattern = pattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-          const regex = new RegExp(`^${regexPattern}$`);
-
-          // 过滤匹配的键
-          result = this.list.filter(key => regex.test(key));
-        }
-
-        // 触发后置事件
-        this.emit('keys_after', { 
-          value: { pattern }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('keys_error', { 
-          value: { pattern }, 
-          error 
-        });
-        $.log.error('[cachebase] keys操作失败:', error);
-        resolve([]);
-      }
-    });
-  }
-
-  // 清空缓存方法，包含事件触发
-  async clear(pattern) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          value: { pattern }, 
-          cancel: false 
-        };
-        this.emit('clear_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let keysToDelete;
-        
-        if (!pattern || pattern === '*') {
-          keysToDelete = [...this.list];
-        } else {
-          // 转换模式为正则表达式
-          const regexPattern = pattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-          const regex = new RegExp(`^${regexPattern}$`);
-          
-          keysToDelete = this.list.filter(key => regex.test(key));
-        }
-
-        // 删除匹配的键
-        keysToDelete.forEach(key => {
-          delete this.data[key];
-          const index = this.list.indexOf(key);
-          if (index > -1) {
-            this.list.splice(index, 1);
-          }
-        });
-
-        // 触发后置事件
-        this.emit('clear_after', { 
-          value: { pattern }, 
-          result: keysToDelete.length 
-        });
-        resolve(keysToDelete.length);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('clear_error', { 
-          value: { pattern }, 
-          error 
-        });
-        $.log.error('[cachebase] clear操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 哈希表获取字段值方法，包含事件触发
-  async hget(key, field) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { field }, 
-          cancel: false 
-        };
-        this.emit('hget_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj && typeof obj.value === 'object' && field in obj.value) {
-          result = obj.value[field];
-        }
-
-        // 触发后置事件
-        this.emit('hget_after', { 
-          key, 
-          value: { field }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hget_error', { 
-          key, 
-          value: { field }, 
-          error 
-        });
-        $.log.error('[cachebase] hget操作失败:', error);
-        resolve(null);
-      }
-    });
-  }
-
-  // 哈希表获取所有字段和值方法，包含事件触发
-  async hgetall(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('hgetall_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve({});
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = {};
-        if (obj && typeof obj.value === 'object') {
-          result = {...obj.value};
-        }
-
-        // 触发后置事件
-        this.emit('hgetall_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hgetall_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] hgetall操作失败:', error);
-        resolve({});
-      }
-    });
-  }
-
-  // 哈希表删除字段方法，包含事件触发
-  async hdel(key, field) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { field }, 
-          cancel: false 
-        };
-        this.emit('hdel_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && typeof obj.value === 'object' && field in obj.value) {
-          delete obj.value[field];
-          // 如果哈希表变空了，删除整个键
-          if (Object.keys(obj.value).length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
-          result = 1;
-        }
-
-        // 触发后置事件
-        this.emit('hdel_after', { 
-          key, 
-          value: { field }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hdel_error', { 
-          key, 
-          value: { field }, 
-          error 
-        });
-        $.log.error('[cachebase] hdel操作失败:', error);
-        resolve(0);
-      }
-    });
-  }
-
-  // 哈希表获取所有字段名方法，包含事件触发
-  async hkeys(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('hkeys_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result = [];
-        const obj = this.data[key];
-        if (obj && typeof obj.value === 'object') {
-          result = Object.keys(obj.value);
-        }
-
-        // 触发后置事件
-        this.emit('hkeys_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hkeys_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] hkeys操作失败:', error);
-        resolve([]);
-      }
-    });
-  }
-
-  // 哈希表获取所有字段值方法，包含事件触发
-  async hvals(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('hvals_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
+          resolve(-2);
           return;
         }
 
         // 执行实际操作
-        let result = [];
         const obj = this.data[key];
-        if (obj && typeof obj.value === 'object') {
-          result = Object.values(obj.value);
+        let result;
+        
+        if (!obj) {
+          result = -2; // 键不存在
+        } else {
+          // 查询过期时间
+          if (obj.expire === 0) {
+            result = -1; // 永不过期
+          } else {
+            const remaining = Math.floor((obj.expire - Date.now()) / 1000);
+            result = remaining > 0 ? remaining : -2; // -2表示已过期
+          }
         }
 
         // 触发后置事件
-        this.emit('hvals_after', { 
-          key, 
+        this.emit('ttl_after', { 
+          key,
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('hvals_error', { 
-          key, 
+        this.emit('ttl_error', { 
+          key,
           error 
         });
-        $.log.error('[cachebase] hvals操作失败:', error);
-        resolve([]);
+        $.log.error('[cachebase] ttl操作失败:', error);
+        resolve(-2);
       }
     });
   }
 
-  // 列表左侧弹出方法，包含事件触发
-  async lpop(key) {
+  // Redis兼容的expire方法
+  async expire(key, seconds) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
+          key,
+          value: { seconds },
           cancel: false 
         };
-        this.emit('lpop_before', beforeEventData);
+        this.emit('expire_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(null);
+          resolve(0);
           return;
         }
 
         // 执行实际操作
         const obj = this.data[key];
-        let result = null;
-        if (obj && Array.isArray(obj.value) && obj.value.length > 0) {
-          result = obj.value.shift();
-          // 如果列表变空了，删除整个键
-          if (obj.value.length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
+        let result = 0;
+        
+        if (obj) {
+          if (seconds === 0) {
+            obj.expire = 0; // 永不过期
+          } else {
+            obj.expire = Date.now() + (parseInt(seconds, 10) * 1000);
           }
+          result = 1;
         }
 
         // 触发后置事件
-        this.emit('lpop_after', { 
-          key, 
+        this.emit('expire_after', { 
+          key,
+          value: { seconds },
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('lpop_error', { 
-          key, 
+        this.emit('expire_error', { 
+          key,
+          value: { seconds },
           error 
         });
-        $.log.error('[cachebase] lpop操作失败:', error);
-        resolve(null);
+        $.log.error('[cachebase] expire操作失败:', error);
+        resolve(0);
       }
     });
   }
 
-  // 列表右侧推入元素方法
-  async rpush(key, ...values) {
+  // Redis兼容的persist方法
+  async persist(key) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value: { values }, 
+          key,
           cancel: false 
         };
-        this.emit('rpush_before', beforeEventData);
+        this.emit('persist_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
@@ -1627,100 +742,93 @@ class CacheBase extends EventEmitter {
           return;
         }
 
-        // 确保列表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: [], expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (!Array.isArray(this.data[key].value)) {
-          this.data[key].value = [];
+        // 执行实际操作
+        const obj = this.data[key];
+        let result = 0;
+        
+        if (obj && obj.expire !== 0) {
+          obj.expire = 0; // 移除过期时间
+          result = 1;
         }
 
-        // 将值添加到列表尾部
-        this.data[key].value.push(...values);
-
         // 触发后置事件
-        this.emit('rpush_after', { 
-          key, 
-          value: { values }, 
-          result: this.data[key].value.length 
+        this.emit('persist_after', { 
+          key,
+          result 
         });
-        resolve(this.data[key].value.length);
+        resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('rpush_error', { 
-          key, 
-          value: { values }, 
+        this.emit('persist_error', { 
+          key,
           error 
         });
-        $.log.error('[cachebase] rpush操作失败:', error);
+        $.log.error('[cachebase] persist操作失败:', error);
         resolve(0);
       }
     });
   }
 
-  // 列表右侧弹出元素方法，包含事件触发
-  async rpop(key) {
+  // 获取所有匹配键方法，包含事件触发
+  async keys(pattern) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
+          value: { pattern }, 
           cancel: false 
         };
-        this.emit('rpop_before', beforeEventData);
+        this.emit('keys_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(null);
+          resolve([]);
           return;
         }
 
         // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj && Array.isArray(obj.value) && obj.value.length > 0) {
-          result = obj.value.pop();
-          // 如果列表变空了，删除整个键
-          if (obj.value.length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
+        let result;
+        if (!pattern || pattern === '*') {
+          result = [...this.list];
+        } else {
+          // 转换模式为正则表达式
+          const regexPattern = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+          const regex = new RegExp(`^${regexPattern}$`);
+
+          // 过滤匹配的键
+          result = this.list.filter(key => regex.test(key));
         }
 
         // 触发后置事件
-        this.emit('rpop_after', { 
-          key, 
+        this.emit('keys_after', { 
+          value: { pattern }, 
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('rpop_error', { 
-          key, 
+        this.emit('keys_error', { 
+          value: { pattern }, 
           error 
         });
-        $.log.error('[cachebase] rpop操作失败:', error);
-        resolve(null);
+        $.log.error('[cachebase] keys操作失败:', error);
+        resolve([]);
       }
     });
   }
 
-  // 获取列表长度方法，包含事件触发
-  async llen(key) {
+  // Redis兼容的dbsize方法
+  async dbsize() {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
           cancel: false 
         };
-        this.emit('llen_before', beforeEventData);
+        this.emit('dbsize_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
@@ -1729,141 +837,123 @@ class CacheBase extends EventEmitter {
         }
 
         // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && Array.isArray(obj.value)) {
-          result = obj.value.length;
-        }
+        const result = this.list.length;
 
         // 触发后置事件
-        this.emit('llen_after', { 
-          key, 
+        this.emit('dbsize_after', { 
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('llen_error', { 
-          key, 
+        this.emit('dbsize_error', { 
           error 
         });
-        $.log.error('[cachebase] llen操作失败:', error);
+        $.log.error('[cachebase] dbsize操作失败:', error);
         resolve(0);
       }
     });
   }
 
-  // 集合移除元素方法，包含事件触发
-  async srem(key, value) {
+  // Redis兼容的flushdb方法
+  async flushdb() {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value, 
           cancel: false 
         };
-        this.emit('srem_before', beforeEventData);
+        this.emit('flushdb_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve(0);
+          resolve(null);
           return;
         }
 
         // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members) {
-          if (obj.value.members.hasOwnProperty(value)) {
-            delete obj.value.members[value];
-            // 更新有序数组
-            obj.value.sorted = Object.keys(obj.value.members);
-            result = 1;
-            // 如果集合变空了，删除整个键
-            if (Object.keys(obj.value.members).length === 0) {
-              delete this.data[key];
-              const index = this.list.indexOf(key);
-              if (index > -1) {
-                this.list.splice(index, 1);
-              }
-            }
-          }
-        }
+        this.data = {};
+        this.list = [];
+        this.dict = this.data; // 同步dict引用
 
         // 触发后置事件
-        this.emit('srem_after', { 
-          key, 
-          value, 
-          result 
+        this.emit('flushdb_after', { 
+          result: 'OK' 
         });
-        resolve(result);
+        resolve('OK');
       } catch (error) {
         // 触发错误事件
-        this.emit('srem_error', { 
-          key, 
-          value, 
+        this.emit('flushdb_error', { 
           error 
         });
-        $.log.error('[cachebase] srem操作失败:', error);
-        resolve(0);
+        $.log.error('[cachebase] flushdb操作失败:', error);
+        resolve(null);
       }
     });
   }
 
-  // 获取集合所有成员方法，包含事件触发
-  async smembers(key) {
+  // Redis兼容的incr方法
+  async incr(key) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
+          key,
           cancel: false 
         };
-        this.emit('smembers_before', beforeEventData);
+        this.emit('incr_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve([]);
+          resolve(0);
           return;
         }
 
-        // 执行实际操作
-        let result = [];
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.sorted) {
-          result = [...obj.value.sorted];
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递增
+        const result = currentValue + 1;
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
         }
 
         // 触发后置事件
-        this.emit('smembers_after', { 
-          key, 
+        this.emit('incr_after', { 
+          key,
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('smembers_error', { 
-          key, 
+        this.emit('incr_error', { 
+          key,
           error 
         });
-        $.log.error('[cachebase] smembers操作失败:', error);
-        resolve([]);
+        $.log.error('[cachebase] incr操作失败:', error);
+        resolve(0);
       }
     });
   }
 
-  // 检查元素是否在集合中方法，包含事件触发
-  async sismember(key, value) {
+  // Redis兼容的decr方法
+  async decr(key) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value, 
+          key,
           cancel: false 
         };
-        this.emit('sismember_before', beforeEventData);
+        this.emit('decr_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
@@ -1871,43 +961,52 @@ class CacheBase extends EventEmitter {
           return;
         }
 
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members && obj.value.members.hasOwnProperty(value)) {
-          result = 1;
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递减
+        const result = currentValue - 1;
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
         }
 
         // 触发后置事件
-        this.emit('sismember_after', { 
-          key, 
-          value, 
+        this.emit('decr_after', { 
+          key,
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('sismember_error', { 
-          key, 
-          value, 
+        this.emit('decr_error', { 
+          key,
           error 
         });
-        $.log.error('[cachebase] sismember操作失败:', error);
+        $.log.error('[cachebase] decr操作失败:', error);
         resolve(0);
       }
     });
   }
 
-  // 获取集合大小方法，包含事件触发
-  async scard(key) {
+  // Redis兼容的incrby方法
+  async incrby(key, increment) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
+          key,
+          value: { increment },
           cancel: false 
         };
-        this.emit('scard_before', beforeEventData);
+        this.emit('incrby_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
@@ -1915,96 +1014,109 @@ class CacheBase extends EventEmitter {
           return;
         }
 
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.sorted) {
-          result = obj.value.sorted.length;
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递增
+        const result = currentValue + parseInt(increment, 10);
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
         }
 
         // 触发后置事件
-        this.emit('scard_after', { 
-          key, 
+        this.emit('incrby_after', { 
+          key,
+          value: { increment },
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('scard_error', { 
-          key, 
+        this.emit('incrby_error', { 
+          key,
+          value: { increment },
           error 
         });
-        $.log.error('[cachebase] scard操作失败:', error);
+        $.log.error('[cachebase] incrby操作失败:', error);
         resolve(0);
       }
     });
   }
 
-  // 获取有序集合范围内的成员方法，包含事件触发
-  async zrange(key, start, stop, withScores = false) {
+  // Redis兼容的decrby方法
+  async decrby(key, decrement) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value: { start, stop, withScores }, 
+          key,
+          value: { decrement },
           cancel: false 
         };
-        this.emit('zrange_before', beforeEventData);
+        this.emit('decrby_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
-          resolve([]);
+          resolve(0);
           return;
         }
 
-        // 执行实际操作
-        let result = [];
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.sorted) {
-          const sorted = obj.value.sorted.slice(start, stop + 1);
-          if (withScores) {
-            result = [];
-            for (const member of sorted) {
-              result.push(member);
-              result.push(obj.value.members[member]);
-            }
-          } else {
-            result = sorted;
-          }
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseInt(this.data[key].value, 10);
+        }
+
+        // 执行递减
+        const result = currentValue - parseInt(decrement, 10);
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
         }
 
         // 触发后置事件
-        this.emit('zrange_after', { 
-          key, 
-          value: { start, stop, withScores }, 
+        this.emit('decrby_after', { 
+          key,
+          value: { decrement },
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('zrange_error', { 
-          key, 
-          value: { start, stop, withScores }, 
+        this.emit('decrby_error', { 
+          key,
+          value: { decrement },
           error 
         });
-        $.log.error('[cachebase] zrange操作失败:', error);
-        resolve([]);
+        $.log.error('[cachebase] decrby操作失败:', error);
+        resolve(0);
       }
     });
   }
 
-  // 从有序集合中移除成员方法，包含事件触发
-  async zrem(key, member) {
+  // Redis兼容的incrbyfloat方法
+  async incrbyfloat(key, increment) {
     return new Promise((resolve) => {
       try {
         // 触发前置事件
         const beforeEventData = { 
-          key, 
-          value: { member }, 
+          key,
+          value: { increment },
           cancel: false 
         };
-        this.emit('zrem_before', beforeEventData);
+        this.emit('incrbyfloat_before', beforeEventData);
 
         // 如果事件处理器设置了cancel为true，则取消操作
         if (beforeEventData.cancel) {
@@ -2012,89 +1124,62 @@ class CacheBase extends EventEmitter {
           return;
         }
 
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members && obj.value.members.hasOwnProperty(member)) {
-          delete obj.value.members[member];
-          // 重新排序
-          obj.value.sorted = Object.entries(obj.value.members)
-            .sort((a, b) => a[1] - b[1])
-            .map(entry => entry[0]);
-          result = 1;
-          // 如果集合变空了，删除整个键
-          if (Object.keys(obj.value.members).length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
+        // 获取当前值或默认为0
+        let currentValue = 0;
+        if (this.data[key] && !isNaN(this.data[key].value)) {
+          currentValue = parseFloat(this.data[key].value);
+        }
+
+        // 执行浮点递增
+        const result = currentValue + parseFloat(increment);
+        
+        // 保存结果
+        this.data[key] = { value: result, expire: 0 };
+        
+        // 如果键不存在于列表中，添加到列表
+        if (!this.list.includes(key)) {
+          this.list.push(key);
         }
 
         // 触发后置事件
-        this.emit('zrem_after', { 
-          key, 
-          value: { member }, 
+        this.emit('incrbyfloat_after', { 
+          key,
+          value: { increment },
           result 
         });
         resolve(result);
       } catch (error) {
         // 触发错误事件
-        this.emit('zrem_error', { 
-          key, 
-          value: { member }, 
+        this.emit('incrbyfloat_error', { 
+          key,
+          value: { increment },
           error 
         });
-        $.log.error('[cachebase] zrem操作失败:', error);
+        $.log.error('[cachebase] incrbyfloat操作失败:', error);
         resolve(0);
       }
     });
   }
 
-  // 获取有序集合中成员的分数方法，包含事件触发
-  async zscore(key, member) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { member }, 
-          cancel: false 
-        };
-        this.emit('zscore_before', beforeEventData);
+  // 保持兼容性的方法
+  async has(key) {
+    return this.exists(key);
+  }
 
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
+  async clear(pattern) {
+    return this.flushdb();
+  }
 
-        // 执行实际操作
-        let result = null;
-        const obj = this.data[key];
-        if (obj && obj.value && obj.value.members && obj.value.members.hasOwnProperty(member)) {
-          result = obj.value.members[member];
-        }
+  async add(key, value) {
+    return this.incrby(key, value);
+  }
 
-        // 触发后置事件
-        this.emit('zscore_after', { 
-          key, 
-          value: { member }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('zscore_error', { 
-          key, 
-          value: { member }, 
-          error 
-        });
-        $.log.error('[cachebase] zscore操作失败:', error);
-        resolve(null);
-      }
-    });
+  async addFloat(key, value) {
+    return this.incrbyfloat(key, value);
+  }
+
+  async addStr(key, value) {
+    return this.append(key, value);
   }
 
   // 资源销毁方法，包含事件触发