resplite 1.4.4 → 1.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resplite",
-  "version": "1.4.4",
+  "version": "1.4.8",
   "description": "A RESP2 server with practical Redis compatibility, backed by SQLite",
   "type": "module",
   "main": "src/index.js",

package/scripts/benchmark-redis-vs-resplite.js

@@ -346,6 +346,13 @@ async function benchZcount(client, n) {
   for (let i = 0; i < n; i++) await client.sendCommand(['ZCOUNT', key, '0', '99']);
 }
 
+async function benchZcard(client, n) {
+  const key = 'bm:zset:card';
+  await client.del(key);
+  await client.zAdd(key, Array.from({ length: 100 }, (_, i) => ({ score: i, value: `m${i}` })));
+  for (let i = 0; i < n; i++) await client.sendCommand(['ZCARD', key]);
+}
+
 async function benchZincrby(client, n) {
   const key = 'bm:zset:incr';
   await client.del(key);
@@ -353,7 +360,31 @@ async function benchZincrby(client, n) {
   for (let i = 0; i < n; i++) await client.sendCommand(['ZINCRBY', key, '1', 'member']);
 }
 
-async function benchZremrangebyrank(client, n) {
+async function benchZremrangebyrankPure(client, n) {
+  const key = 'bm:zset:remrank:pure';
+  const seed = Array.from({ length: 100 }, (_, j) => ({ score: j, value: `m${j}` }));
+  const refill = Array.from({ length: 10 }, (_, j) => ({ score: j, value: `m${j}` }));
+  await client.del(key);
+  await client.zAdd(key, seed);
+  for (let i = 0; i < n; i++) {
+    await client.sendCommand(['ZREMRANGEBYRANK', key, '0', '9']);
+    await client.zAdd(key, refill);
+  }
+}
+
+async function benchZremrangebyscorePure(client, n) {
+  const key = 'bm:zset:remscore:pure';
+  const seed = Array.from({ length: 100 }, (_, j) => ({ score: j, value: `m${j}` }));
+  const refill = Array.from({ length: 10 }, (_, j) => ({ score: j, value: `m${j}` }));
+  await client.del(key);
+  await client.zAdd(key, seed);
+  for (let i = 0; i < n; i++) {
+    await client.sendCommand(['ZREMRANGEBYSCORE', key, '0', '9']);
+    await client.zAdd(key, refill);
+  }
+}
+
+async function benchZremrangebyrankChurn(client, n) {
   const key = 'bm:zset:remrank';
   for (let i = 0; i < n; i++) {
     await client.del(key);
@@ -362,7 +393,7 @@ async function benchZremrangebyrank(client, n) {
   }
 }
 
-async function benchZremrangebyscore(client, n) {
+async function benchZremrangebyscoreChurn(client, n) {
   const key = 'bm:zset:remscore';
   for (let i = 0; i < n; i++) {
     await client.del(key);
@@ -390,6 +421,14 @@ async function benchSrandmember(client, n) {
   for (let i = 0; i < n; i++) await client.sendCommand(['SRANDMEMBER', key]);
 }
 
+async function benchHincrby(client, n) {
+  const key = 'bm:hash:incr';
+  const field = 'counter';
+  await client.del(key);
+  await client.hSet(key, field, '0');
+  for (let i = 0; i < n; i++) await client.sendCommand(['HINCRBY', key, field, '1']);
+}
+
 const FT_INDEX = 'bm_ft_idx';
 const FT_DOCS = 50;
 
@@ -447,11 +486,15 @@ const SUITES = [
   { name: 'LTRIM', fn: benchLtrim, iterScale: 1 },
   { name: 'RENAME', fn: benchRename, iterScale: 1 },
   { name: 'ZCOUNT', fn: benchZcount, iterScale: 1 },
+  { name: 'ZCARD(100)', fn: benchZcard, iterScale: 1 },
   { name: 'ZINCRBY', fn: benchZincrby, iterScale: 1 },
-  { name: 'ZREMRANGEBYRANK', fn: benchZremrangebyrank, iterScale: 1 },
-  { name: 'ZREMRANGEBYSCORE', fn: benchZremrangebyscore, iterScale: 1 },
+  { name: 'ZREMRANGEBYRANK (pure)', fn: benchZremrangebyrankPure, iterScale: 1 },
+  { name: 'ZREMRANGEBYSCORE (pure)', fn: benchZremrangebyscorePure, iterScale: 1 },
+  { name: 'ZREMRANGEBYRANK (churn)', fn: benchZremrangebyrankChurn, iterScale: 1 },
+  { name: 'ZREMRANGEBYSCORE (churn)', fn: benchZremrangebyscoreChurn, iterScale: 1 },
   { name: 'SPOP', fn: benchSpop, iterScale: 1 },
   { name: 'SRANDMEMBER', fn: benchSrandmember, iterScale: 1 },
+  { name: 'HINCRBY', fn: benchHincrby, iterScale: 1 },
   { name: 'FT.SEARCH', fn: benchFtSearch, iterScale: 1 },
 ];
 

package/spec/08-type-sorted-sets.md

@@ -91,8 +91,8 @@ Notes:
 
 * Return cardinality:
 
-  * Prefer `SELECT COUNT(*)` (acceptable).
-  * If performance needs: maintain count in a meta table (not needed initially).
+  * Prefer metadata counter (`redis_keys.zset_count`) for O(1) reads.
+  * Backward compatibility: if counter is missing/null, hydrate once from `SELECT COUNT(*)`.
 
 ### C.5.4 ZSCORE
 

package/src/commands/score-bounds.js

@@ -0,0 +1,15 @@
+/**
+ * Parse score bound used by sorted-set score range commands.
+ * Supports Redis-style infinities: -inf, +inf, inf.
+ *
+ * @param {Buffer|string|number} raw
+ * @returns {number|null}
+ */
+export function parseScoreBound(raw) {
+  const s = Buffer.isBuffer(raw) ? raw.toString('utf8') : String(raw);
+  const lower = s.toLowerCase();
+  if (lower === '-inf') return Number.NEGATIVE_INFINITY;
+  if (lower === '+inf' || lower === 'inf') return Number.POSITIVE_INFINITY;
+  const n = parseFloat(s);
+  return Number.isNaN(n) ? null : n;
+}

package/src/commands/zcount.js

@@ -2,14 +2,16 @@
  * ZCOUNT key min max - returns count of members in sorted set with score in [min, max].
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZcount(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZCOUNT\' command' };
   }
   try {
-    const min = parseFloat(String(args[1]));
-    const max = parseFloat(String(args[2]));
-    if (Number.isNaN(min) || Number.isNaN(max)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const n = engine.zcount(args[0], min, max);

package/src/commands/zrangebyscore.js

@@ -2,6 +2,8 @@
  * ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZRANGEBYSCORE\' command' };
@@ -25,9 +27,9 @@ export function handleZrangebyscore(engine, args) {
     }
   }
   try {
-    const min = parseFloat(String(args[1]));
-    const max = parseFloat(String(args[2]));
-    if (Number.isNaN(min) || Number.isNaN(max)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const options = { withScores };

package/src/commands/zremrangebyscore.js

@@ -2,14 +2,16 @@
  * ZREMRANGEBYSCORE key min max - removes members with score in [min, max]. Returns count removed.
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZremrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZREMRANGEBYSCORE\' command' };
   }
   try {
-    const min = parseFloat(String(args[1]));
-    const max = parseFloat(String(args[2]));
-    if (Number.isNaN(min) || Number.isNaN(max)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const n = engine.zremrangebyscore(args[0], min, max);

package/src/commands/zrevrangebyscore.js

@@ -4,6 +4,8 @@
  * Note: Redis uses max min (first score is upper bound, second is lower bound).
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZrevrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZREVRANGEBYSCORE\' command' };
@@ -27,9 +29,9 @@ export function handleZrevrangebyscore(engine, args) {
     }
   }
   try {
-    const max = parseFloat(String(args[1]));
-    const min = parseFloat(String(args[2]));
-    if (Number.isNaN(max) || Number.isNaN(min)) {
+    const max = parseScoreBound(args[1]);
+    const min = parseScoreBound(args[2]);
+    if (max == null || min == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const options = { withScores };

package/src/engine/engine.js

@@ -567,7 +567,12 @@ export function createEngine(opts = {}) {
       if (k.equals(nk)) return;
       runInTransaction(db, () => {
         if (keys.get(nk)) keys.delete(nk);
-        keys.set(nk, meta.type, { expiresAt: meta.expiresAt });
+        keys.set(nk, meta.type, {
+          expiresAt: meta.expiresAt,
+          setCount: meta.type === KEY_TYPES.SET ? meta.setCount : undefined,
+          hashCount: meta.type === KEY_TYPES.HASH ? meta.hashCount : undefined,
+          zsetCount: meta.type === KEY_TYPES.ZSET ? meta.zsetCount : undefined,
+        });
         switch (meta.type) {
           case KEY_TYPES.STRING:
             strings.copyKey(k, nk);

package/src/storage/sqlite/hashes.js

@@ -32,15 +32,31 @@ export function createHashesStorage(db, keys) {
       runInTransaction(db, () => {
         const now = options.updatedAt ?? Date.now();
         const meta = keys.get(key);
+        let knownCount = 0;
         if (meta) {
           if (meta.type !== KEY_TYPES.HASH) {
             throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
           }
           keys.bumpVersion(key);
+          if (meta.hashCount == null) {
+            const row = countStmt.get(key);
+            knownCount = (row && row.n) || 0;
+            keys.setHashCount(key, knownCount, { touchUpdatedAt: false });
+          } else {
+            knownCount = meta.hashCount;
+          }
         } else {
-          keys.set(key, KEY_TYPES.HASH, { updatedAt: now });
+          keys.set(key, KEY_TYPES.HASH, { updatedAt: now, hashCount: 0 });
         }
+        const existed = getStmt.get(key, field) != null;
         insertStmt.run(key, field, value);
+        if (!existed) {
+          if (meta) keys.incrHashCount(key, 1, { touchUpdatedAt: false });
+          else keys.setHashCount(key, 1, { touchUpdatedAt: false });
+        } else if (meta && meta.hashCount == null) {
+          // Legacy rows may have null counters; persist hydrated value.
+          keys.setHashCount(key, knownCount, { touchUpdatedAt: false });
+        }
       });
     },
 
@@ -48,39 +64,70 @@ export function createHashesStorage(db, keys) {
       runInTransaction(db, () => {
         const now = options.updatedAt ?? Date.now();
         const meta = keys.get(key);
+        let knownCount = 0;
         if (meta) {
           if (meta.type !== KEY_TYPES.HASH) {
             throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
           }
           keys.bumpVersion(key);
+          if (meta.hashCount == null) {
+            const row = countStmt.get(key);
+            knownCount = (row && row.n) || 0;
+            keys.setHashCount(key, knownCount, { touchUpdatedAt: false });
+          } else {
+            knownCount = meta.hashCount;
+          }
         } else {
-          keys.set(key, KEY_TYPES.HASH, { updatedAt: now });
+          keys.set(key, KEY_TYPES.HASH, { updatedAt: now, hashCount: 0 });
         }
+        let added = 0;
         for (let i = 0; i < pairs.length; i += 2) {
+          const existed = getStmt.get(key, pairs[i]) != null;
           insertStmt.run(key, pairs[i], pairs[i + 1]);
+          if (!existed) added++;
+        }
+        if (added > 0) {
+          if (meta) keys.incrHashCount(key, added, { touchUpdatedAt: false });
+          else keys.setHashCount(key, added, { touchUpdatedAt: false });
+        } else if (meta && meta.hashCount == null) {
+          // Legacy rows may have null counters; persist hydrated value.
+          keys.setHashCount(key, knownCount, { touchUpdatedAt: false });
         }
       });
     },
 
     delete(key, fields) {
       return runInTransaction(db, () => {
+        const meta = keys.get(key);
+        const before = meta && meta.hashCount != null ? meta.hashCount : null;
         let n = 0;
         for (const field of fields) {
           const r = deleteStmt.run(key, field);
           n += r.changes;
         }
-        const remaining = (countStmt.get(key) || {}).n ?? 0;
+        const remaining = before != null ? Math.max(0, before - n) : ((countStmt.get(key) || {}).n ?? 0);
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
+        } else if (n > 0) {
+          keys.setHashCount(key, remaining, { touchUpdatedAt: false });
         }
         return n;
       });
     },
 
     count(key) {
+      const meta = keys.get(key);
+      if (meta && meta.type === KEY_TYPES.HASH && meta.hashCount != null) {
+        return meta.hashCount;
+      }
       const row = countStmt.get(key);
-      return row ? row.n : 0;
+      const n = row ? row.n : 0;
+      if (meta && meta.type === KEY_TYPES.HASH && meta.hashCount == null) {
+        // One-time hydration for databases created before hash_count existed.
+        keys.setHashCount(key, n, { touchUpdatedAt: false });
+      }
+      return n;
     },
 
     incr(key, field, delta, options = {}) {
@@ -91,15 +138,24 @@ export function createHashesStorage(db, keys) {
           throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
         }
         if (!meta) {
-          keys.set(key, KEY_TYPES.HASH, { updatedAt: now });
+          keys.set(key, KEY_TYPES.HASH, { updatedAt: now, hashCount: 0 });
         } else {
           keys.bumpVersion(key);
+          if (meta.hashCount == null) {
+            const row = countStmt.get(key);
+            const hydrated = (row && row.n) || 0;
+            keys.setHashCount(key, hydrated, { touchUpdatedAt: false });
+          }
         }
         const cur = getStmt.get(key, field);
         const num = cur == null ? 0 : parseInt(cur.value.toString('utf8'), 10);
         if (Number.isNaN(num)) throw new Error('ERR hash value is not an integer');
         const next = num + delta;
         insertStmt.run(key, field, Buffer.from(String(next), 'utf8'));
+        if (cur == null) {
+          if (meta) keys.incrHashCount(key, 1, { touchUpdatedAt: false });
+          else keys.setHashCount(key, 1, { touchUpdatedAt: false });
+        }
         return next;
       });
     },
@@ -107,9 +163,12 @@ export function createHashesStorage(db, keys) {
     /** Copy all field/value rows from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
     copyKey(oldKey, newKey) {
       const rows = getAllStmt.all(oldKey);
-      for (let i = 0; i < rows.length; i += 2) {
-        insertStmt.run(newKey, rows[i], rows[i + 1]);
+      for (const row of rows) {
+        insertStmt.run(newKey, row[0], row[1]);
       }
+      const sourceMeta = keys.get(oldKey);
+      const nextCount = sourceMeta && sourceMeta.hashCount != null ? sourceMeta.hashCount : rows.length;
+      keys.setHashCount(newKey, nextCount, { touchUpdatedAt: false });
     },
   };
 }

package/src/storage/sqlite/keys.js

@@ -9,16 +9,34 @@ import { KEY_TYPES } from './schema.js';
  */
 export function createKeysStorage(db) {
   const getByKey = db.prepare(
-    'SELECT key, type, expires_at AS expiresAt, version, updated_at AS updatedAt FROM redis_keys WHERE key = ?'
+    'SELECT key, type, expires_at AS expiresAt, set_count AS setCount, hash_count AS hashCount, zset_count AS zsetCount, version, updated_at AS updatedAt FROM redis_keys WHERE key = ?'
   );
   const insert = db.prepare(
-    `INSERT INTO redis_keys (key, type, expires_at, version, updated_at) VALUES (?, ?, ?, 1, ?)`
+    `INSERT INTO redis_keys (key, type, expires_at, set_count, hash_count, zset_count, version, updated_at) VALUES (?, ?, ?, ?, ?, ?, 1, ?)`
   );
   const updateMeta = db.prepare(
-    'UPDATE redis_keys SET type = ?, expires_at = ?, version = version + 1, updated_at = ? WHERE key = ?'
+    'UPDATE redis_keys SET type = ?, expires_at = ?, set_count = ?, hash_count = ?, zset_count = ?, version = version + 1, updated_at = ? WHERE key = ?'
   );
   const updateExpires = db.prepare('UPDATE redis_keys SET expires_at = ?, updated_at = ? WHERE key = ?');
   const updateVersion = db.prepare('UPDATE redis_keys SET version = version + 1, updated_at = ? WHERE key = ?');
+  const updateSetCount = db.prepare('UPDATE redis_keys SET set_count = ?, updated_at = ? WHERE key = ?');
+  const updateSetCountOnly = db.prepare('UPDATE redis_keys SET set_count = ? WHERE key = ?');
+  const incrSetCount = db.prepare(
+    'UPDATE redis_keys SET set_count = COALESCE(set_count, 0) + ?, updated_at = ? WHERE key = ?'
+  );
+  const incrSetCountOnly = db.prepare('UPDATE redis_keys SET set_count = COALESCE(set_count, 0) + ? WHERE key = ?');
+  const updateHashCount = db.prepare('UPDATE redis_keys SET hash_count = ?, updated_at = ? WHERE key = ?');
+  const updateHashCountOnly = db.prepare('UPDATE redis_keys SET hash_count = ? WHERE key = ?');
+  const incrHashCount = db.prepare(
+    'UPDATE redis_keys SET hash_count = COALESCE(hash_count, 0) + ?, updated_at = ? WHERE key = ?'
+  );
+  const incrHashCountOnly = db.prepare('UPDATE redis_keys SET hash_count = COALESCE(hash_count, 0) + ? WHERE key = ?');
+  const updateZsetCount = db.prepare('UPDATE redis_keys SET zset_count = ?, updated_at = ? WHERE key = ?');
+  const updateZsetCountOnly = db.prepare('UPDATE redis_keys SET zset_count = ? WHERE key = ?');
+  const incrZsetCount = db.prepare(
+    'UPDATE redis_keys SET zset_count = COALESCE(zset_count, 0) + ?, updated_at = ? WHERE key = ?'
+  );
+  const incrZsetCountOnly = db.prepare('UPDATE redis_keys SET zset_count = COALESCE(zset_count, 0) + ? WHERE key = ?');
   const deleteByKey = db.prepare('DELETE FROM redis_keys WHERE key = ?');
   const deleteExpiredStmt = db.prepare('DELETE FROM redis_keys WHERE expires_at IS NOT NULL AND expires_at <= ?');
   const countAll = db.prepare('SELECT COUNT(*) AS n FROM redis_keys').pluck();
@@ -38,10 +56,19 @@ export function createKeysStorage(db) {
       const now = options.updatedAt ?? Date.now();
       const expiresAt = options.expiresAt ?? null;
       const existing = getByKey.get(key);
+      const setCount = type === KEY_TYPES.SET
+        ? (options.setCount ?? existing?.setCount ?? 0)
+        : null;
+      const hashCount = type === KEY_TYPES.HASH
+        ? (options.hashCount ?? existing?.hashCount ?? 0)
+        : null;
+      const zsetCount = type === KEY_TYPES.ZSET
+        ? (options.zsetCount ?? existing?.zsetCount ?? 0)
+        : null;
       if (existing) {
-        updateMeta.run(type, expiresAt, now, key);
+        updateMeta.run(type, expiresAt, setCount, hashCount, zsetCount, now, key);
       } else {
-        insert.run(key, type, expiresAt, now);
+        insert.run(key, type, expiresAt, setCount, hashCount, zsetCount, now);
       }
     },
 
@@ -53,6 +80,60 @@ export function createKeysStorage(db) {
       updateVersion.run(Date.now(), key);
     },
 
+    setSetCount(key, setCount, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        updateSetCount.run(setCount, options.updatedAt ?? Date.now(), key);
+      } else {
+        updateSetCountOnly.run(setCount, key);
+      }
+    },
+
+    incrSetCount(key, delta, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        incrSetCount.run(delta, options.updatedAt ?? Date.now(), key);
+      } else {
+        incrSetCountOnly.run(delta, key);
+      }
+    },
+
+    setHashCount(key, hashCount, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        updateHashCount.run(hashCount, options.updatedAt ?? Date.now(), key);
+      } else {
+        updateHashCountOnly.run(hashCount, key);
+      }
+    },
+
+    incrHashCount(key, delta, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        incrHashCount.run(delta, options.updatedAt ?? Date.now(), key);
+      } else {
+        incrHashCountOnly.run(delta, key);
+      }
+    },
+
+    setZsetCount(key, zsetCount, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        updateZsetCount.run(zsetCount, options.updatedAt ?? Date.now(), key);
+      } else {
+        updateZsetCountOnly.run(zsetCount, key);
+      }
+    },
+
+    incrZsetCount(key, delta, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        incrZsetCount.run(delta, options.updatedAt ?? Date.now(), key);
+      } else {
+        incrZsetCountOnly.run(delta, key);
+      }
+    },
+
     delete(key) {
       return deleteByKey.run(key);
     },

package/src/storage/sqlite/schema.js

@@ -7,6 +7,9 @@ CREATE TABLE IF NOT EXISTS redis_keys (
   key BLOB PRIMARY KEY,
   type INTEGER NOT NULL,
   expires_at INTEGER,
+  set_count INTEGER,
+  hash_count INTEGER,
+  zset_count INTEGER,
   version INTEGER NOT NULL DEFAULT 1,
   updated_at INTEGER NOT NULL
 );
@@ -86,4 +89,18 @@ export const KEY_TYPES = {
  */
 export function applySchema(db) {
   db.exec(SCHEMA);
+  // Backward-compatible migration for databases created before count columns existed.
+  const cols = db.prepare('PRAGMA table_info(redis_keys)').all();
+  const hasSetCount = cols.some((c) => c.name === 'set_count');
+  const hasHashCount = cols.some((c) => c.name === 'hash_count');
+  const hasZsetCount = cols.some((c) => c.name === 'zset_count');
+  if (!hasSetCount) {
+    db.exec('ALTER TABLE redis_keys ADD COLUMN set_count INTEGER;');
+  }
+  if (!hasHashCount) {
+    db.exec('ALTER TABLE redis_keys ADD COLUMN hash_count INTEGER;');
+  }
+  if (!hasZsetCount) {
+    db.exec('ALTER TABLE redis_keys ADD COLUMN zset_count INTEGER;');
+  }
 }

package/src/storage/sqlite/sets.js

@@ -22,34 +22,52 @@ export function createSetsStorage(db, keys) {
       return runInTransaction(db, () => {
         const now = options.updatedAt ?? Date.now();
         const meta = keys.get(key);
+        let knownCount = 0;
         if (meta) {
           if (meta.type !== KEY_TYPES.SET) {
             throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
           }
           keys.bumpVersion(key);
+          if (meta.setCount == null) {
+            const row = countStmt.get(key);
+            knownCount = (row && row.n) || 0;
+            keys.setSetCount(key, knownCount, { touchUpdatedAt: false });
+          } else {
+            knownCount = meta.setCount;
+          }
         } else {
-          keys.set(key, KEY_TYPES.SET, { updatedAt: now });
+          keys.set(key, KEY_TYPES.SET, { updatedAt: now, setCount: 0 });
         }
         let added = 0;
         for (const m of members) {
           const r = insertStmt.run(key, m);
           if (r.changes > 0) added++;
         }
+        if (added > 0) {
+          if (meta) keys.incrSetCount(key, added, { touchUpdatedAt: false });
+          else keys.setSetCount(key, added, { touchUpdatedAt: false });
+        } else if (meta && meta.setCount == null) {
+          // Legacy rows may have null counters; persist hydrated value.
+          keys.setSetCount(key, knownCount, { touchUpdatedAt: false });
+        }
         return added;
       });
     },
 
     remove(key, members) {
       return runInTransaction(db, () => {
+        const meta = keys.get(key);
+        const before = meta && meta.setCount != null ? meta.setCount : null;
         let n = 0;
         for (const m of members) {
           n += deleteStmt.run(key, m).changes;
         }
-        const row = countStmt.get(key);
-        const remaining = (row && row.n) || 0;
+        const remaining = before != null ? Math.max(0, before - n) : ((countStmt.get(key) || {}).n || 0);
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
+        } else if (n > 0) {
+          keys.setSetCount(key, remaining, { touchUpdatedAt: false });
         }
         return n;
       });
@@ -65,8 +83,17 @@ export function createSetsStorage(db, keys) {
     },
 
     count(key) {
+      const meta = keys.get(key);
+      if (meta && meta.type === KEY_TYPES.SET && meta.setCount != null) {
+        return meta.setCount;
+      }
       const row = countStmt.get(key);
-      return row ? row.n : 0;
+      const n = row ? row.n : 0;
+      if (meta && meta.type === KEY_TYPES.SET && meta.setCount == null) {
+        // One-time hydration for databases created before set_count existed.
+        keys.setSetCount(key, n, { touchUpdatedAt: false });
+      }
+      return n;
     },
 
     /** Copy all members from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
@@ -75,6 +102,9 @@ export function createSetsStorage(db, keys) {
       for (const r of rows) {
         insertStmt.run(newKey, r.member);
       }
+      const sourceMeta = keys.get(oldKey);
+      const nextCount = sourceMeta && sourceMeta.setCount != null ? sourceMeta.setCount : rows.length;
+      keys.setSetCount(newKey, nextCount, { touchUpdatedAt: false });
     },
 
     /** Get random members without removing. count null/1 = single; count > 0 = up to count distinct; count < 0 = |count| with replacement. */
@@ -117,13 +147,13 @@ export function createSetsStorage(db, keys) {
           for (let i = 0; i < -c; i++) chosen.push(arr[Math.floor(Math.random() * arr.length)]);
         }
         for (const m of chosen) deleteStmt.run(key, m);
-        const row = countStmt.get(key);
-        const remaining = (row && row.n) || 0;
+        const remaining = arr.length - chosen.length;
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
         } else {
           keys.bumpVersion(key);
+          keys.setSetCount(key, remaining, { touchUpdatedAt: false });
         }
         return c === 1 ? chosen[0] : chosen;
       });

package/src/storage/sqlite/zsets.js

@@ -26,6 +26,12 @@ export function createZsetsStorage(db, keys) {
     `INSERT INTO redis_zsets (key, member, score) VALUES (?, ?, ?)
      ON CONFLICT(key, member) DO UPDATE SET score = excluded.score`
   );
+  const insertIgnoreStmt = db.prepare(
+    'INSERT OR IGNORE INTO redis_zsets (key, member, score) VALUES (?, ?, ?)'
+  );
+  const updateScoreStmt = db.prepare(
+    'UPDATE redis_zsets SET score = ? WHERE key = ? AND member = ?'
+  );
   const deleteStmt = db.prepare('DELETE FROM redis_zsets WHERE key = ? AND member = ?');
   const deleteAllStmt = db.prepare('DELETE FROM redis_zsets WHERE key = ?');
   const countStmt = db.prepare('SELECT COUNT(*) AS n FROM redis_zsets WHERE key = ?');
@@ -82,19 +88,40 @@ export function createZsetsStorage(db, keys) {
       return runInTransaction(db, () => {
         const now = options.updatedAt ?? Date.now();
         const meta = keys.get(key);
+        let knownCount = 0;
         if (meta) {
           if (meta.type !== KEY_TYPES.ZSET) {
             throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
           }
           keys.bumpVersion(key);
+          if (meta.zsetCount == null) {
+            const row = countStmt.get(key);
+            knownCount = (row && row.n) || 0;
+            keys.setZsetCount(key, knownCount, { touchUpdatedAt: false });
+          } else {
+            knownCount = meta.zsetCount;
+          }
         } else {
-          keys.set(key, KEY_TYPES.ZSET, { updatedAt: now });
+          keys.set(key, KEY_TYPES.ZSET, { updatedAt: now, zsetCount: 0 });
         }
         let newCount = 0;
         for (const { score, member } of pairs) {
-          const existed = scoreStmt.get(key, member) != null;
-          upsertStmt.run(key, member, score);
-          if (!existed) newCount++;
+          const inserted = insertIgnoreStmt.run(key, member, score).changes;
+          if (inserted > 0) {
+            newCount++;
+          } else {
+            updateScoreStmt.run(score, key, member);
+          }
+        }
+        if (newCount > 0) {
+          if (meta) {
+            keys.incrZsetCount(key, newCount, { touchUpdatedAt: false });
+          } else {
+            keys.setZsetCount(key, newCount, { touchUpdatedAt: false });
+          }
+        } else if (meta && meta.zsetCount == null) {
+          // Legacy rows may have null counters; persist the hydrated value.
+          keys.setZsetCount(key, knownCount, { touchUpdatedAt: false });
         }
         return newCount;
       });
@@ -108,23 +135,35 @@ export function createZsetsStorage(db, keys) {
      */
     remove(key, members) {
       return runInTransaction(db, () => {
+        const meta = keys.get(key);
+        const before = meta && meta.zsetCount != null ? meta.zsetCount : null;
         let n = 0;
         for (const m of members) {
           n += deleteStmt.run(key, m).changes;
         }
-        const row = countStmt.get(key);
-        const remaining = (row && row.n) || 0;
+        const remaining = before != null ? Math.max(0, before - n) : ((countStmt.get(key) || {}).n || 0);
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
+        } else if (n > 0) {
+          keys.setZsetCount(key, remaining, { touchUpdatedAt: false });
         }
         return n;
       });
     },
 
     count(key) {
+      const meta = keys.get(key);
+      if (meta && meta.type === KEY_TYPES.ZSET && meta.zsetCount != null) {
+        return meta.zsetCount;
+      }
       const row = countStmt.get(key);
-      return row ? row.n : 0;
+      const n = row ? row.n : 0;
+      if (meta && meta.type === KEY_TYPES.ZSET && meta.zsetCount == null) {
+        // One-time hydration for databases created before zset_count existed.
+        keys.setZsetCount(key, n, { touchUpdatedAt: false });
+      }
+      return n;
     },
 
     score(key, member) {
@@ -270,9 +309,15 @@ export function createZsetsStorage(db, keys) {
       for (const r of rows) {
         upsertStmt.run(newKey, r.member, r.score);
       }
+      const sourceMeta = keys.get(oldKey);
+      const nextCount = sourceMeta && sourceMeta.zsetCount != null ? sourceMeta.zsetCount : rows.length;
+      keys.setZsetCount(newKey, nextCount, { touchUpdatedAt: false });
     },
 
     countByScore(key, min, max) {
+      if (min === Number.NEGATIVE_INFINITY && max === Number.POSITIVE_INFINITY) {
+        return this.count(key);
+      }
       const row = countByScoreStmt.get(key, min, max);
       return row ? row.n : 0;
     },
@@ -285,14 +330,23 @@ export function createZsetsStorage(db, keys) {
           throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
         }
         if (!meta) {
-          keys.set(key, KEY_TYPES.ZSET, { updatedAt: now });
+          keys.set(key, KEY_TYPES.ZSET, { updatedAt: now, zsetCount: 0 });
         } else {
           keys.bumpVersion(key);
+          if (meta.zsetCount == null) {
+            const row = countStmt.get(key);
+            const hydrated = (row && row.n) || 0;
+            keys.setZsetCount(key, hydrated, { touchUpdatedAt: false });
+          }
         }
         const cur = scoreStmt.get(key, member);
         const prev = cur == null ? 0 : cur.score;
         const next = prev + increment;
         upsertStmt.run(key, member, next);
+        if (cur == null) {
+          if (meta) keys.incrZsetCount(key, 1, { touchUpdatedAt: false });
+          else keys.setZsetCount(key, 1, { touchUpdatedAt: false });
+        }
         return formatScore(next);
       });
     },
@@ -318,6 +372,8 @@ export function createZsetsStorage(db, keys) {
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
+        } else if (n > 0) {
+          keys.setZsetCount(key, remaining, { touchUpdatedAt: false });
         }
         return n;
       });
@@ -333,6 +389,7 @@ export function createZsetsStorage(db, keys) {
           keys.delete(key);
         } else if (r.changes > 0) {
           keys.bumpVersion(key);
+          keys.setZsetCount(key, n, { touchUpdatedAt: false });
         }
         return r.changes;
       });

package/test/integration/hashes.test.js

@@ -1,5 +1,6 @@
 import { describe, it, before, after } from 'node:test';
 import assert from 'node:assert/strict';
+import Database from 'better-sqlite3';
 import { createTestServer } from '../helpers/server.js';
 import { sendCommand, argv } from '../helpers/client.js';
 import { tryParseValue } from '../../src/resp/parser.js';
@@ -56,4 +57,33 @@ describe('Hashes integration', () => {
     const reply = await sendCommand(port, argv('HLEN', 'hlen:str'));
     assert.ok(reply.toString('utf8').includes('WRONGTYPE'));
   });
+
+  it('RENAME keeps hash cardinality metadata', async () => {
+    await sendCommand(port, argv('HSET', 'hrename:src', 'a', '1', 'b', '2', 'c', '3'));
+    await sendCommand(port, argv('RENAME', 'hrename:src', 'hrename:dst'));
+    const reply = await sendCommand(port, argv('HLEN', 'hrename:dst'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('legacy hash rows with null hash_count hydrate on first HLEN', async () => {
+    const s1 = await createTestServer();
+    await sendCommand(s1.port, argv('HSET', 'legacy:h', 'f1', 'v1', 'f2', 'v2'));
+    const dbPath = s1.dbPath;
+    await s1.closeAsync();
+    s1.db.close();
+
+    const legacyDb = new Database(dbPath);
+    legacyDb.prepare('UPDATE redis_keys SET hash_count = NULL WHERE key = ?').run(Buffer.from('legacy:h', 'utf8'));
+    legacyDb.close();
+
+    const s2 = await createTestServer({ dbPath });
+    const first = await sendCommand(s2.port, argv('HLEN', 'legacy:h'));
+    assert.equal(tryParseValue(first, 0).value, 2);
+    const second = await sendCommand(s2.port, argv('HLEN', 'legacy:h'));
+    assert.equal(tryParseValue(second, 0).value, 2);
+
+    const row = s2.db.prepare('SELECT hash_count AS n FROM redis_keys WHERE key = ?').get(Buffer.from('legacy:h', 'utf8'));
+    assert.equal(row.n, 2);
+    await s2.closeAsync();
+  });
 });

package/test/integration/sets.test.js

@@ -1,7 +1,9 @@
 import { describe, it, before, after } from 'node:test';
 import assert from 'node:assert/strict';
+import Database from 'better-sqlite3';
 import { createTestServer } from '../helpers/server.js';
 import { sendCommand, argv } from '../helpers/client.js';
+import { tryParseValue } from '../../src/resp/parser.js';
 
 describe('Sets integration', () => {
   let s;
@@ -24,4 +26,51 @@ describe('Sets integration', () => {
     assert.ok(s.includes('$1\r\nb\r\n'));
     assert.ok(s.includes('$1\r\nc\r\n'));
   });
+
+  it('SCARD returns member count', async () => {
+    await sendCommand(port, argv('SADD', 'scard:1', 'a', 'b', 'c'));
+    const reply = await sendCommand(port, argv('SCARD', 'scard:1'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('SCARD on non-existent key returns 0', async () => {
+    const reply = await sendCommand(port, argv('SCARD', 'scard:none'));
+    assert.equal(tryParseValue(reply, 0).value, 0);
+  });
+
+  it('SCARD decreases after SREM', async () => {
+    await sendCommand(port, argv('SADD', 'scard:2', 'x', 'y'));
+    await sendCommand(port, argv('SREM', 'scard:2', 'x'));
+    const reply = await sendCommand(port, argv('SCARD', 'scard:2'));
+    assert.equal(tryParseValue(reply, 0).value, 1);
+  });
+
+  it('RENAME keeps set cardinality metadata', async () => {
+    await sendCommand(port, argv('SADD', 'srename:src', 'm1', 'm2', 'm3'));
+    await sendCommand(port, argv('RENAME', 'srename:src', 'srename:dst'));
+    const reply = await sendCommand(port, argv('SCARD', 'srename:dst'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('legacy set rows with null set_count hydrate on first SCARD', async () => {
+    const s1 = await createTestServer();
+    await sendCommand(s1.port, argv('SADD', 'legacy:s', 'a', 'b'));
+    const dbPath = s1.dbPath;
+    await s1.closeAsync();
+    s1.db.close();
+
+    const legacyDb = new Database(dbPath);
+    legacyDb.prepare('UPDATE redis_keys SET set_count = NULL WHERE key = ?').run(Buffer.from('legacy:s', 'utf8'));
+    legacyDb.close();
+
+    const s2 = await createTestServer({ dbPath });
+    const first = await sendCommand(s2.port, argv('SCARD', 'legacy:s'));
+    assert.equal(tryParseValue(first, 0).value, 2);
+    const second = await sendCommand(s2.port, argv('SCARD', 'legacy:s'));
+    assert.equal(tryParseValue(second, 0).value, 2);
+
+    const row = s2.db.prepare('SELECT set_count AS n FROM redis_keys WHERE key = ?').get(Buffer.from('legacy:s', 'utf8'));
+    assert.equal(row.n, 2);
+    await s2.closeAsync();
+  });
 });

package/test/integration/zsets.test.js

@@ -1,5 +1,6 @@
 import { describe, it, before, after } from 'node:test';
 import assert from 'node:assert/strict';
+import Database from 'better-sqlite3';
 import { createTestServer } from '../helpers/server.js';
 import { sendCommand, argv } from '../helpers/client.js';
 import { tryParseValue } from '../../src/resp/parser.js';
@@ -40,6 +41,15 @@ describe('ZSET integration', () => {
     assert.equal(score.toString('utf8'), '20');
   });
 
+  it('ZADD with duplicate member in same command counts as new once and keeps last score', async () => {
+    const added = await sendCommand(port, argv('ZADD', 'zdup', '1', 'm', '2', 'm'));
+    assert.equal(tryParseValue(added, 0).value, 1);
+
+    const scoreReply = await sendCommand(port, argv('ZSCORE', 'zdup', 'm'));
+    const score = tryParseValue(scoreReply, 0).value;
+    assert.equal(score.toString('utf8'), '2');
+  });
+
   it('ZRANGE WITHSCORES returns member, score, ...', async () => {
     await sendCommand(port, argv('ZADD', 'z3', '1', 'x', '2', 'y'));
     const reply = await sendCommand(port, argv('ZRANGE', 'z3', '0', '-1', 'WITHSCORES'));
@@ -149,6 +159,37 @@ describe('ZSET integration', () => {
     assert.equal(limited[1].toString('utf8'), 'c');
   });
 
+  it('ZCOUNT supports numeric ranges and full-range infinities', async () => {
+    await sendCommand(port, argv('ZADD', 'zc1', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+
+    const mid = await sendCommand(port, argv('ZCOUNT', 'zc1', '2', '3'));
+    assert.equal(tryParseValue(mid, 0).value, 2);
+
+    const all = await sendCommand(port, argv('ZCOUNT', 'zc1', '-inf', '+inf'));
+    assert.equal(tryParseValue(all, 0).value, 4);
+  });
+
+  it('score-range commands accept -inf/+inf bounds', async () => {
+    await sendCommand(port, argv('ZADD', 'zinf', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+
+    const rangeAll = await sendCommand(port, argv('ZRANGEBYSCORE', 'zinf', '-inf', '+inf'));
+    const rAll = tryParseValue(rangeAll, 0).value;
+    assert.equal(rAll.length, 4);
+    assert.equal(rAll[0].toString('utf8'), 'a');
+    assert.equal(rAll[3].toString('utf8'), 'd');
+
+    const revAll = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zinf', '+inf', '-inf'));
+    const rvAll = tryParseValue(revAll, 0).value;
+    assert.equal(rvAll.length, 4);
+    assert.equal(rvAll[0].toString('utf8'), 'd');
+    assert.equal(rvAll[3].toString('utf8'), 'a');
+
+    const removed = await sendCommand(port, argv('ZREMRANGEBYSCORE', 'zinf', '-inf', '+inf'));
+    assert.equal(tryParseValue(removed, 0).value, 4);
+    const card = await sendCommand(port, argv('ZCARD', 'zinf'));
+    assert.equal(tryParseValue(card, 0).value, 0);
+  });
+
   it('ZCARD non-existent returns 0, ZSCORE non-existent returns nil', async () => {
     const cardReply = await sendCommand(port, argv('ZCARD', 'nonexistent_z'));
     assert.equal(tryParseValue(cardReply, 0).value, 0);
@@ -201,6 +242,35 @@ describe('ZSET integration', () => {
     await s2.closeAsync();
   });
 
+  it('RENAME keeps zset cardinality metadata', async () => {
+    await sendCommand(port, argv('ZADD', 'zrename_src', '1', 'a', '2', 'b', '3', 'c'));
+    await sendCommand(port, argv('RENAME', 'zrename_src', 'zrename_dst'));
+    const cardReply = await sendCommand(port, argv('ZCARD', 'zrename_dst'));
+    assert.equal(tryParseValue(cardReply, 0).value, 3);
+  });
+
+  it('legacy zset rows with null zset_count hydrate on first ZCARD', async () => {
+    const s1 = await createTestServer();
+    await sendCommand(s1.port, argv('ZADD', 'legacy_z', '1', 'one', '2', 'two'));
+    const dbPath = s1.dbPath;
+    await s1.closeAsync();
+    s1.db.close();
+
+    const legacyDb = new Database(dbPath);
+    legacyDb.prepare('UPDATE redis_keys SET zset_count = NULL WHERE key = ?').run(Buffer.from('legacy_z', 'utf8'));
+    legacyDb.close();
+
+    const s2 = await createTestServer({ dbPath });
+    const first = await sendCommand(s2.port, argv('ZCARD', 'legacy_z'));
+    assert.equal(tryParseValue(first, 0).value, 2);
+    const second = await sendCommand(s2.port, argv('ZCARD', 'legacy_z'));
+    assert.equal(tryParseValue(second, 0).value, 2);
+
+    const row = s2.db.prepare('SELECT zset_count AS n FROM redis_keys WHERE key = ?').get(Buffer.from('legacy_z', 'utf8'));
+    assert.equal(row.n, 2);
+    await s2.closeAsync();
+  });
+
   it('binary-safe zset members', async () => {
     const bin = Buffer.from([0x00, 0xff]);
     await sendCommand(port, argv('ZADD', 'zbin', '1', 'normal'));