mm_mongodb 1.4.5 → 1.4.6

package/index.js

@@ -154,6 +154,1139 @@ class MongoDB extends eventEmitter {
 		// 所有重试都失败，抛出最后一个错误
 		throw lastError;
 	}
+	
+	/**
+	 * @description Redis兼容API - 获取缓存值
+	 * @param {String} key 键名
+	 * @return {Promise<any>} 缓存值
+	 */
+	async get(key) {
+		try {
+			const result = await this.findOne({ key: key });
+			return result ? result.value : null;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取缓存失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 清空所有缓存
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async clear() {
+		try {
+			await this.del({});
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 清空缓存失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取所有键
+	 * @param {String} pattern 匹配模式
+	 * @return {Promise<Array>} 键名数组
+	 */
+	async keys(pattern = '*') {
+		try {
+			let query = {};
+			if (pattern !== '*') {
+				// 简单的通配符支持
+				const regexPattern = pattern.replace(/\*/g, '.*').replace(/\?/g, '.');
+				query.key = { $regex: new RegExp(`^${regexPattern}$`) };
+			}
+			const results = await this.find(query, { projection: { key: 1 } });
+			return results.map(item => item.key);
+		} catch (error) {
+			$.log.error('[MongoDB] 获取键列表失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 设置过期时间
+	 * @param {String} key 键名
+	 * @param {Number} seconds 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async ttl(key, seconds) {
+		try {
+			if (!seconds && seconds !== 0) {
+				// 获取剩余过期时间
+				const item = await this.findOne({ key: key });
+				if (!item || !item.expireAt) return -1;
+				const ttl = Math.floor((item.expireAt.getTime() - Date.now()) / 1000);
+				return ttl > 0 ? ttl : -2; // -2 表示已过期
+			} else {
+				// 设置过期时间
+				const expireAt = seconds === 0 ? null : new Date(Date.now() + seconds * 1000);
+				const result = await this.set({ key: key }, { expireAt: expireAt });
+				return result.modifiedCount > 0;
+			}
+		} catch (error) {
+			$.log.error('[MongoDB] 设置TTL失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 添加缓存
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @param {Number} expire 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async add(key, value, expire) {
+		try {
+			const data = {
+				key: key,
+				value: value
+			};
+			
+			if (expire) {
+				data.expireAt = new Date(Date.now() + expire * 1000);
+			}
+			
+			// 检查是否已存在
+			const existing = await this.findOne({ key: key });
+			if (existing) {
+				await this.set({ key: key }, data);
+			} else {
+				await this.addObj(data);
+			}
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 添加缓存失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 增加整数值
+	 * @param {String} key 键名
+	 * @param {Number} value 增加值
+	 * @return {Promise<Number>} 增加后的值
+	 */
+	async addInt(key, value = 1) {
+		try {
+			const item = await this.findOne({ key: key });
+			let currentValue = 0;
+			
+			if (item && typeof item.value === 'number') {
+				currentValue = item.value;
+			}
+			
+			const newValue = currentValue + value;
+			await this.add(key, newValue);
+			return newValue;
+		} catch (error) {
+			$.log.error('[MongoDB] 增加整数值失败:', error);
+			return undefined;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 增加浮点数值
+	 * @param {String} key 键名
+	 * @param {Number} value 增加值
+	 * @return {Promise<Number>} 增加后的值
+	 */
+	async addFloat(key, value = 1.0) {
+		return this.addInt(key, value); // 复用addInt方法
+	}
+	
+	/**
+	 * @description Redis兼容API - 添加字符串
+	 * @param {String} key 键名
+	 * @param {String} value 字符串值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async addStr(key, value) {
+		return this.add(key, String(value));
+	}
+	
+	/**
+	 * @description Redis兼容API - 排序
+	 * @param {String} key 键名
+	 * @param {Object} options 排序选项
+	 * @return {Promise<Array>} 排序结果
+	 */
+	async sort(key, options = {}) {
+		try {
+			// 假设value是数组
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) return [];
+			
+			const sorted = [...item.value];
+			
+			// 处理排序选项
+			if (options.desc) {
+				sorted.sort((a, b) => b - a);
+			} else {
+				sorted.sort((a, b) => a - b);
+			}
+			
+			// 处理限制
+			if (options.limit) {
+				const offset = options.offset || 0;
+				return sorted.slice(offset, offset + options.limit);
+			}
+			
+			return sorted;
+		} catch (error) {
+			$.log.error('[MongoDB] 排序失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表设置字段
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hset(key, field, value) {
+		try {
+			const item = await this.findOne({ key: key });
+			let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
+			
+			hash[field] = value;
+			await this.add(key, hash);
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表设置失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表获取字段
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @return {Promise<any>} 字段值
+	 */
+	async hget(key, field) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return null;
+			}
+			return item.value[field] !== undefined ? item.value[field] : null;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表获取失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表获取所有字段和值
+	 * @param {String} key 键名
+	 * @return {Promise<Object>} 哈希表对象
+	 */
+	async hgetall(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return {};
+			}
+			return item.value;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表获取全部失败:', error);
+			return {};
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表删除字段
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hdel(key, field) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return false;
+			}
+			
+			if (item.value[field] === undefined) {
+				return false;
+			}
+			
+			delete item.value[field];
+			await this.set({ key: key }, { value: item.value });
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表删除失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 检查键是否存在
+	 * @param {String} key 键名
+	 * @return {Promise<Boolean>} 是否存在
+	 */
+	async has(key) {
+		try {
+			const result = await this.findOne({ key: key });
+			return result !== null;
+		} catch (error) {
+			$.log.error('[MongoDB] 检查键是否存在失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 设置键过期时间（映射到ttl）
+	 * @param {String} key 键名
+	 * @param {Number} seconds 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async expire(key, seconds) {
+		return this.ttl(key, seconds);
+	}
+	
+	/**
+	 * @description Redis兼容API - 递增（通过addInt模拟）
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 递增后的值
+	 */
+	async incr(key) {
+		return this.addInt(key, 1);
+	}
+	
+	/**
+	 * @description Redis兼容API - 递减（通过addInt模拟）
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 递减后的值
+	 */
+	async decr(key) {
+		return this.addInt(key, -1);
+	}
+	
+	/**
+	 * @description Redis兼容API - 检查键是否存在（别名）
+	 * @param {String} key 键名
+	 * @return {Promise<Boolean>} 是否存在
+	 */
+	async exists(key) {
+		return this.has(key);
+	}
+	
+	/**
+	 * @description Redis兼容API - 设置键值
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async set(key, value) {
+		try {
+			// 直接使用已有的add方法，它已正确处理查询条件格式
+			return await this.add(key, value);
+		} catch (error) {
+			$.log.error('[MongoDB] 设置键值失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表批量设置
+	 * @param {String} key 键名
+	 * @param {Object} fieldValues 字段值对象
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hmset(key, fieldValues) {
+		try {
+			const item = await this.findOne({ key: key });
+			let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
+			
+			// 合并字段值
+			Object.assign(hash, fieldValues);
+			await this.add(key, hash);
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表批量设置失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表批量获取
+	 * @param {String} key 键名
+	 * @param {Array} fields 字段名数组
+	 * @return {Promise<Object>} 字段值对象
+	 */
+	async hmget(key, fields) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return {};
+			}
+			
+			const result = {};
+			fields.forEach(field => {
+				result[field] = item.value[field] !== undefined ? item.value[field] : null;
+			});
+			return result;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表批量获取失败:', error);
+			return {};
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表批量删除字段
+	 * @param {String} key 键名
+	 * @param {Array} fields 字段名数组
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hdelMulti(key, fields) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return false;
+			}
+			
+			let deleted = false;
+			fields.forEach(field => {
+				if (item.value[field] !== undefined) {
+					delete item.value[field];
+					deleted = true;
+				}
+			});
+			
+			if (deleted) {
+				await this.set({ key: key }, { value: item.value });
+			}
+			return deleted;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表批量删除失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表获取所有值
+	 * @param {String} key 键名
+	 * @return {Promise<Array>} 值数组
+	 */
+	async hvals(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return [];
+			}
+			return Object.values(item.value);
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表获取所有值失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表获取所有字段名
+	 * @param {String} key 键名
+	 * @return {Promise<Array>} 字段名数组
+	 */
+	async hkeys(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return [];
+			}
+			return Object.keys(item.value);
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表获取所有字段名失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表字段数量
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 字段数量
+	 */
+	async hlen(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return 0;
+			}
+			return Object.keys(item.value).length;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表字段数量失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表字段是否存在
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @return {Promise<Boolean>} 是否存在
+	 */
+	async hexists(key, field) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return false;
+			}
+			return field in item.value;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表字段是否存在失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表尾部添加元素
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Number>} 添加后列表长度
+	 */
+	async rpush(key, value) {
+		try {
+			const item = await this.findOne({ key: key });
+			let list = item && Array.isArray(item.value) ? item.value : [];
+			
+			list.push(value);
+			await this.add(key, list);
+			return list.length;
+		} catch (error) {
+			$.log.error('[MongoDB] 列表尾部添加失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表头部添加元素
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Number>} 添加后列表长度
+	 */
+	async lpush(key, value) {
+		try {
+			const item = await this.findOne({ key: key });
+			let list = item && Array.isArray(item.value) ? item.value : [];
+			
+			list.unshift(value);
+			await this.add(key, list);
+			return list.length;
+		} catch (error) {
+			$.log.error('[MongoDB] 列表头部添加失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表范围查询
+	 * @param {String} key 键名
+	 * @param {Number} start 起始索引
+	 * @param {Number} stop 结束索引
+	 * @return {Promise<Array>} 元素数组
+	 */
+	async lrange(key, start, stop) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return [];
+			}
+			
+			// 处理负数索引
+			let startIndex = start < 0 ? item.value.length + start : start;
+			let endIndex = stop < 0 ? item.value.length + stop : stop;
+			
+			// 确保索引有效
+			startIndex = Math.max(0, Math.min(startIndex, item.value.length - 1));
+			endIndex = Math.max(startIndex, Math.min(endIndex, item.value.length - 1));
+			
+			return item.value.slice(startIndex, endIndex + 1);
+		} catch (error) {
+			$.log.error('[MongoDB] 列表范围查询失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取列表指定索引元素
+	 * @param {String} key 键名
+	 * @param {Number} index 索引
+	 * @return {Promise<any>} 元素值
+	 */
+	async lindex(key, index) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return null;
+			}
+			
+			// 处理负数索引
+			const realIndex = index < 0 ? item.value.length + index : index;
+			
+			if (realIndex < 0 || realIndex >= item.value.length) {
+				return null;
+			}
+			
+			return item.value[realIndex];
+		} catch (error) {
+			$.log.error('[MongoDB] 获取列表索引元素失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 设置列表指定索引元素
+	 * @param {String} key 键名
+	 * @param {Number} index 索引
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async lset(key, index, value) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return false;
+			}
+			
+			// 处理负数索引
+			const realIndex = index < 0 ? item.value.length + index : index;
+			
+			if (realIndex < 0 || realIndex >= item.value.length) {
+				return false;
+			}
+			
+			item.value[realIndex] = value;
+			await this.set({ key: key }, { value: item.value });
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 设置列表索引元素失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 删除列表元素
+	 * @param {String} key 键名
+	 * @param {Number} count 删除数量
+	 * @param {*} value 要删除的值
+	 * @return {Promise<Number>} 删除的元素数量
+	 */
+	async lrem(key, count, value) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			
+			let list = [...item.value];
+			let removedCount = 0;
+			
+			if (count > 0) {
+				// 从头部删除count个等于value的元素
+				for (let i = 0; i < list.length && removedCount < count; i++) {
+					if (JSON.stringify(list[i]) === JSON.stringify(value)) {
+						list.splice(i, 1);
+						removedCount++;
+						i--; // 调整索引
+					}
+				}
+			} else if (count < 0) {
+				// 从尾部删除|count|个等于value的元素
+				count = Math.abs(count);
+				for (let i = list.length - 1; i >= 0 && removedCount < count; i--) {
+					if (JSON.stringify(list[i]) === JSON.stringify(value)) {
+						list.splice(i, 1);
+						removedCount++;
+					}
+				}
+			} else {
+				// 删除所有等于value的元素
+				list = list.filter(item => JSON.stringify(item) !== JSON.stringify(value));
+				removedCount = item.value.length - list.length;
+			}
+			
+			if (removedCount > 0) {
+				await this.set({ key: key }, { value: list });
+			}
+			
+			return removedCount;
+		} catch (error) {
+			$.log.error('[MongoDB] 删除列表元素失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 裁剪列表
+	 * @param {String} key 键名
+	 * @param {Number} start 起始索引
+	 * @param {Number} stop 结束索引
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async ltrim(key, start, stop) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return false;
+			}
+			
+			// 使用lrange的逻辑获取裁剪后的列表
+			const trimmed = await this.lrange(key, start, stop);
+			await this.set({ key: key }, { value: trimmed });
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 裁剪列表失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表长度
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 列表长度
+	 */
+	async llen(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			return item.value.length;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取列表长度失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合批量添加
+	 * @param {String} key 键名
+	 * @param {Array} members 成员数组
+	 * @return {Promise<Number>} 添加的成员数量
+	 */
+	async saddMulti(key, members) {
+		try {
+			const item = await this.findOne({ key: key });
+			let set = item && Array.isArray(item.value) ? [...new Set(item.value)] : [];
+			let addedCount = 0;
+			
+			members.forEach(member => {
+				if (!set.some(existing => JSON.stringify(existing) === JSON.stringify(member))) {
+					set.push(member);
+					addedCount++;
+				}
+			});
+			
+			if (addedCount > 0) {
+				await this.add(key, set);
+			}
+			
+			return addedCount;
+		} catch (error) {
+			$.log.error('[MongoDB] 集合并发添加失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合批量删除
+	 * @param {String} key 键名
+	 * @param {Array} members 成员数组
+	 * @return {Promise<Number>} 删除的成员数量
+	 */
+	async sremMulti(key, members) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			
+			let set = [...new Set(item.value)];
+			const originalLength = set.length;
+			
+			// 创建要删除的值的字符串表示集合用于快速查找
+			const membersToRemove = new Set(members.map(m => JSON.stringify(m)));
+			set = set.filter(member => !membersToRemove.has(JSON.stringify(member)));
+			
+			const removedCount = originalLength - set.length;
+			if (removedCount > 0) {
+				await this.add(key, set);
+			}
+			
+			return removedCount;
+		} catch (error) {
+			$.log.error('[MongoDB] 集合并发删除失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合差集
+	 * @param {String} key1 第一个集合键
+	 * @param {String} key2 第二个集合键
+	 * @return {Promise<Array>} 差集数组
+	 */
+	async sdiff(key1, key2) {
+		try {
+			const item1 = await this.findOne({ key: key1 });
+			const item2 = await this.findOne({ key: key2 });
+			
+			const set1 = item1 && Array.isArray(item1.value) ? [...new Set(item1.value)] : [];
+			const set2 = item2 && Array.isArray(item2.value) ? [...new Set(item2.value)] : [];
+			
+			// 创建第二个集合值的字符串表示用于快速查找
+			const set2Str = new Set(set2.map(m => JSON.stringify(m)));
+			
+			// 找出在set1中但不在set2中的元素
+			return set1.filter(member => !set2Str.has(JSON.stringify(member)));
+		} catch (error) {
+			$.log.error('[MongoDB] 集合差集失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合交集
+	 * @param {String} key1 第一个集合键
+	 * @param {String} key2 第二个集合键
+	 * @return {Promise<Array>} 交集数组
+	 */
+	async sinter(key1, key2) {
+		try {
+			const item1 = await this.findOne({ key: key1 });
+			const item2 = await this.findOne({ key: key2 });
+			
+			const set1 = item1 && Array.isArray(item1.value) ? [...new Set(item1.value)] : [];
+			const set2 = item2 && Array.isArray(item2.value) ? [...new Set(item2.value)] : [];
+			
+			// 创建较小集合的字符串表示用于快速查找，优化性能
+			let smallerSet, largerSet;
+			if (set1.length <= set2.length) {
+				smallerSet = set1;
+				largerSet = set2;
+			} else {
+				smallerSet = set2;
+				largerSet = set1;
+			}
+			
+			const largerSetStr = new Set(largerSet.map(m => JSON.stringify(m)));
+			
+			// 找出同时存在于两个集合中的元素
+			return smallerSet.filter(member => largerSetStr.has(JSON.stringify(member)));
+		} catch (error) {
+			$.log.error('[MongoDB] 集合并集失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合并集
+	 * @param {String} key1 第一个集合键
+	 * @param {String} key2 第二个集合键
+	 * @return {Promise<Array>} 并集数组
+	 */
+	async sunion(key1, key2) {
+		try {
+			const item1 = await this.findOne({ key: key1 });
+			const item2 = await this.findOne({ key: key2 });
+			
+			const set1 = item1 && Array.isArray(item1.value) ? item1.value : [];
+			const set2 = item2 && Array.isArray(item2.value) ? item2.value : [];
+			
+			// 合并并去重
+			const combined = [...set1, ...set2];
+			// 使用Map进行对象去重，基于JSON字符串表示
+			const uniqueMap = new Map();
+			
+			combined.forEach(item => {
+				const key = JSON.stringify(item);
+				if (!uniqueMap.has(key)) {
+					uniqueMap.set(key, item);
+				}
+			});
+			
+			return Array.from(uniqueMap.values());
+		} catch (error) {
+			$.log.error('[MongoDB] 集合并集失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合成员数量
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 成员数量
+	 */
+	async scard(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			
+			// 使用Set去重并计算大小
+			const uniqueItems = new Set(item.value.map(m => JSON.stringify(m)));
+			return uniqueItems.size;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取集合成员数量失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 检查是否是集合成员
+	 * @param {String} key 键名
+	 * @param {*} member 成员
+	 * @return {Promise<Boolean>} 是否是成员
+	 */
+	async sismember(key, member) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return false;
+			}
+			
+			// 检查是否存在相同的成员
+			const memberStr = JSON.stringify(member);
+			return item.value.some(m => JSON.stringify(m) === memberStr);
+		} catch (error) {
+			$.log.error('[MongoDB] 检查集合成员失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 批量获取
+	 * @param {Array} keys 键名数组
+	 * @return {Promise<Object>} 键值对象
+	 */
+	async mget(keys) {
+		try {
+			const results = await this.find({ key: { $in: keys } });
+			const resultMap = {};
+			results.forEach(item => {
+				resultMap[item.key] = item.value;
+			});
+			return resultMap;
+		} catch (error) {
+			$.log.error('[MongoDB] 批量获取失败:', error);
+			return {};
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 批量设置
+	 * @param {Object} keyValues 键值对象
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async mset(keyValues) {
+		try {
+			for (const [key, value] of Object.entries(keyValues)) {
+				await this.add(key, value);
+			}
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 批量设置失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 有序集合添加成员
+	 * @param {String} key 键名
+	 * @param {Number} score 分数
+	 * @param {*} member 成员
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async zadd(key, score, member) {
+		try {
+			const item = await this.findOne({ key: key });
+			let sortedSet = item && Array.isArray(item.value) ? item.value : [];
+			
+			// 检查成员是否已存在，如果存在则更新分数
+			const memberStr = JSON.stringify(member);
+			const existingIndex = sortedSet.findIndex(item => JSON.stringify(item.member) === memberStr);
+			
+			if (existingIndex >= 0) {
+				sortedSet[existingIndex].score = score;
+			} else {
+				sortedSet.push({ score, member });
+			}
+			
+			// 按分数排序
+			sortedSet.sort((a, b) => a.score - b.score);
+			await this.add(key, sortedSet);
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合添加成员失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 有序集合范围查询（按分数）
+	 * @param {String} key 键名
+	 * @param {Number} min 最小分数
+	 * @param {Number} max 最大分数
+	 * @return {Promise<Array>} 成员数组
+	 */
+	async zrangebyscore(key, min, max) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return [];
+			}
+			
+			// 过滤分数范围内的成员
+			return item.value
+				.filter(item => item.score >= min && item.score <= max)
+				.map(item => item.member);
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合范围查询失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 有序集合成员数量
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 成员数量
+	 */
+	async zcard(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			return item.value.length;
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合成员数量失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 有序集合删除成员
+	 * @param {String} key 键名
+	 * @param {*} member 成员
+	 * @return {Promise<Number>} 删除的成员数量
+	 */
+	async zrem(key, member) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			
+			const memberStr = JSON.stringify(member);
+			const filtered = item.value.filter(item => JSON.stringify(item.member) !== memberStr);
+			const removedCount = item.value.length - filtered.length;
+			
+			if (removedCount > 0) {
+				await this.add(key, filtered);
+			}
+			
+			return removedCount;
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合删除成员失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取成员分数
+	 * @param {String} key 键名
+	 * @param {*} member 成员
+	 * @return {Promise<Number|null>} 分数
+	 */
+	async zscore(key, member) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return null;
+			}
+			
+			const memberStr = JSON.stringify(member);
+			const found = item.value.find(item => JSON.stringify(item.member) === memberStr);
+			return found ? found.score : null;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取成员分数失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表弹出头部元素
+	 * @param {String} key 键名
+	 * @return {Promise<any|null>} 弹出的元素
+	 */
+	async lpop(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value) || item.value.length === 0) {
+				return null;
+			}
+			
+			const popped = item.value.shift();
+			await this.set({ key: key }, { value: item.value });
+			return popped;
+		} catch (error) {
+			$.log.error('[MongoDB] 列表弹出头部元素失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表弹出尾部元素
+	 * @param {String} key 键名
+	 * @return {Promise<any|null>} 弹出的元素
+	 */
+	async rpop(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value) || item.value.length === 0) {
+				return null;
+			}
+			
+			const popped = item.value.pop();
+			await this.set({ key: key }, { value: item.value });
+			return popped;
+		} catch (error) {
+			$.log.error('[MongoDB] 列表弹出尾部元素失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取集合所有成员
+	 * @param {String} key 键名
+	 * @return {Promise<Array>} 成员数组
+	 */
+	async smembers(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return [];
+			}
+			
+			// 去重并返回
+			const uniqueMap = new Map();
+			item.value.forEach(member => {
+				const keyStr = JSON.stringify(member);
+				if (!uniqueMap.has(keyStr)) {
+					uniqueMap.set(keyStr, member);
+				}
+			});
+			return Array.from(uniqueMap.values());
+		} catch (error) {
+			$.log.error('[MongoDB] 获取集合所有成员失败:', error);
+			return [];
+		}
+	}
 }
 
 /**
@@ -250,28 +1383,6 @@ MongoDB.prototype.addTable = function (table) {
 	return this.db.createCollection(table);
 };
 
-/**
- * @description 创建TTL索引
- * @param {String} table 表名
- * @param {String} field 过期字段名
- * @param {Number} expireAfterSeconds 过期时间(秒)
- * @return {Promise<Object>} 执行结果
- */
-MongoDB.prototype.createTTLIndex = async function (table, field, expireAfterSeconds) {
-	if (!table) table = this.table;
-	return await this.db.collection(table).createIndex(
-		{ [field]: 1 },
-		{ expireAfterSeconds: expireAfterSeconds || 0 }
-	);
-};
-
-/**
- * @description 创建普通索引
- * @param {String} table 表名
- * @param {Object} keys 索引字段对象
- * @param {Object} options 索引选项
- * @return {Promise<Object>} 执行结果
- */
 /**
  * @description 创建索引
  * @param {Object} keys 索引键配置 {field: 1或-1}
@@ -433,19 +1544,22 @@ MongoDB.prototype.addList = async function(list) {
 
 /**
  * @description 删除缓存
- * @param {Object} query 查询条件对象
+ * @param {Object|String} query 查询条件对象或键名
  * @return {Promise|Object} 执行结果
  */
 MongoDB.prototype.del = async function(query) {
 	try {
+		// 如果query是字符串，则作为键名处理
+		const safeQuery = typeof query === 'string' ? { key: query } : query;
+		
 		// 触发前置事件
-		this.emit('beforeDelete', { table: this.table, query });
+		this.emit('beforeDelete', { table: this.table, query: safeQuery });
 		
 		// 执行删除操作
-		const result = await this.db.collection(this.table).deleteMany(query);
+		const result = await this.db.collection(this.table).deleteMany(safeQuery);
 		
 		// 触发后置事件
-		this.emit('afterDelete', { table: this.table, query, result });
+		this.emit('afterDelete', { table: this.table, query: safeQuery, result });
 		
 		return result;
 	} catch (error) {
@@ -457,34 +1571,47 @@ MongoDB.prototype.del = async function(query) {
 
 /**
  * @description 修改缓存
- * @param {Object} query 查询条件对象
+ * @param {Object|String} query 查询条件对象或键名
  * @param {Object} body 修改对象
  * @param {Object} options 附加选项
  * @return {Promise|Object} 执行结果
  */
 MongoDB.prototype.set = async function(query, body, options = {}) {
 	try {
+		// 处理Redis兼容模式：如果query是字符串，则将query作为键名
+		const safeQuery = typeof query === 'string' ? { key: query } : query;
+		
 		// 默认使用$set操作符进行部分更新
-		if (!body.$set && !body.$inc && !body.$push) {
-			body = { $set: body };
+		let updateBody;
+		if (typeof query === 'string') {
+			// Redis兼容模式：如果是字符串键名，直接设置value
+			updateBody = { $set: { value: body } };
+		} else if (!body.$set && !body.$inc && !body.$push) {
+			updateBody = { $set: body };
+		} else {
+			updateBody = body;
 		}
+		
 		// 默认更新多条
 		const updateOptions = Object.assign({ multi: true }, options);
 		
 		// 触发前置事件
-		this.emit('beforeUpdate', { table: this.table, query, update: body, options: updateOptions });
+		this.emit('beforeUpdate', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions });
 		
 		// 执行更新操作
-		const result = await this.db.collection(this.table).updateMany(query, body, updateOptions);
+		const result = await this.db.collection(this.table).updateMany(safeQuery, updateBody, updateOptions);
 		
 		// 触发后置事件
-		this.emit('afterUpdate', { table: this.table, query, update: body, options: updateOptions, result });
+		this.emit('afterUpdate', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions, result });
 		
-		return result;
+		// Redis兼容模式返回布尔值，否则返回完整结果
+		return typeof query === 'string' ? result.modifiedCount > 0 : result;
 	} catch (error) {
 		// 触发错误事件
 		this.emit('updateError', { table: this.table, query, update: body, options, error });
-		throw error;
+		
+		// Redis兼容模式返回布尔值
+		return typeof query === 'string' ? false : null;
 	}
 };