resplite 1.2.8 → 1.2.12

package/README.md

@@ -515,21 +515,24 @@ A typical comparison is **Redis (for example, in Docker)** on one side and **RES
 
 **Example results (Redis vs RESPLite, default pragma, 10k iterations):**
 
-| Suite           | Redis (Docker) | RESPLite (default) |
-|-----------------|----------------|--------------------|
-| PING            | 8.79K/s        | 37.36K/s           |
-| SET+GET         | 4.68K/s        | 11.96K/s           |
-| MSET+MGET(10)   | 4.41K/s        | 5.81K/s            |
-| INCR            | 9.54K/s        | 18.97K/s           |
-| HSET+HGET       | 4.40K/s        | 11.91K/s           |
-| HGETALL(50)     | 8.39K/s        | 11.01K/s           |
-| HLEN(50)        | 9.36K/s        | 31.21K/s           |
-| SADD+SMEMBERS   | 9.27K/s        | 17.37K/s           |
-| LPUSH+LRANGE    | 8.34K/s        | 14.27K/s           |
-| LREM            | 4.37K/s        | 6.08K/s            |
-| ZADD+ZRANGE     | 7.80K/s        | 17.12K/s           |
-| SET+DEL         | 4.39K/s        | 9.57K/s            |
-| FT.SEARCH       | 8.36K/s        | 8.22K/s            |
+| Suite             | Redis (Docker) | RESPLite (default) |
+|-------------------|----------------|--------------------|
+| PING              | 9.72K/s        | 37.66K/s           |
+| SET+GET           | 4.60K/s        | 11.96K/s           |
+| MSET+MGET(10)     | 4.38K/s        | 5.71K/s            |
+| INCR              | 9.76K/s        | 19.15K/s           |
+| HSET+HGET         | 4.42K/s        | 11.71K/s           |
+| HGETALL(50)       | 8.42K/s        | 11.12K/s           |
+| HLEN(50)          | 8.88K/s        | 30.72K/s           |
+| SADD+SMEMBERS     | 8.33K/s        | 18.19K/s           |
+| LPUSH+LRANGE      | 8.29K/s        | 14.78K/s           |
+| LREM              | 4.85K/s        | 6.35K/s            |
+| ZADD+ZRANGE       | 9.37K/s        | 16.43K/s           |
+| ZADD+ZREVRANGE    | 8.22K/s        | 16.82K/s           |
+| ZRANK+ZREVRANK    | 4.56K/s        | 13.03K/s           |
+| ZREVRANGEBYSCORE  | 8.88K/s        | 16.88K/s           |
+| SET+DEL           | 4.75K/s        | 9.99K/s            |
+| FT.SEARCH         | 8.39K/s        | 8.81K/s            |
 
 To reproduce the benchmark, run `npm run benchmark -- --template default`. Numbers depend on host and whether Redis is native or in Docker.
 
@@ -545,7 +548,7 @@ To reproduce the benchmark, run `npm run benchmark -- --template default`. Numbe
 | **Hashes** | HSET, HGET, HMGET, HGETALL, HDEL, HEXISTS, HINCRBY |
 | **Sets** | SADD, SREM, SMEMBERS, SISMEMBER, SCARD |
 | **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, BLPOP, BRPOP |
-| **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZRANGEBYSCORE |
+| **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZREVRANGE, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZRANK, ZREVRANK |
 | **Search (FT.\*)** | FT.CREATE, FT.INFO, FT.ADD, FT.DEL, FT.SEARCH, FT.SUGADD, FT.SUGGET, FT.SUGDEL |
 | **Introspection** | TYPE, OBJECT IDLETIME, SCAN, KEYS, MONITOR |
 | **Admin** | SQLITE.INFO, CACHE.INFO, MEMORY.INFO |

package/package.json

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

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

@@ -258,6 +258,34 @@ async function benchZaddZrange(client, n) {
   }
 }
 
+async function benchZaddZrevrange(client, n) {
+  const key = 'bm:zset:rev';
+  for (let i = 0; i < n; i++) {
+    await client.zAdd(key, { score: i, value: `m${i}` });
+    if (i % 10 === 0) await client.zRange(key, 0, 49, { REV: true });
+  }
+}
+
+async function benchZrankZrevrank(client, n) {
+  const key = 'bm:zset:rank';
+  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++) {
+    const member = `m${i % 100}`;
+    await client.zRank(key, member);
+    await client.zRevRank(key, member);
+  }
+}
+
+async function benchZrevrangebyscore(client, n) {
+  const key = 'bm:zset:byscore';
+  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(['ZREVRANGEBYSCORE', key, '99', '0', 'LIMIT', '0', '20']);
+  }
+}
+
 async function benchDel(client, n) {
   for (let i = 0; i < n; i++) {
     await client.set(`bm:del:${i}`, 'x');
@@ -311,6 +339,9 @@ const SUITES = [
   { name: 'LPUSH+LRANGE', fn: benchLpushLrange, iterScale: 1 },
   { name: 'LREM', fn: benchLrem, iterScale: 1 },
   { name: 'ZADD+ZRANGE', fn: benchZaddZrange, iterScale: 1 },
+  { name: 'ZADD+ZREVRANGE', fn: benchZaddZrevrange, iterScale: 1 },
+  { name: 'ZRANK+ZREVRANK', fn: benchZrankZrevrank, iterScale: 1 },
+  { name: 'ZREVRANGEBYSCORE', fn: benchZrevrangebyscore, iterScale: 1 },
   { name: 'SET+DEL', fn: benchDel, iterScale: 1 },
   { name: 'FT.SEARCH', fn: benchFtSearch, iterScale: 1 },
 ];

package/src/commands/registry.js

@@ -54,6 +54,10 @@ import * as zcard from './zcard.js';
 import * as zscore from './zscore.js';
 import * as zrange from './zrange.js';
 import * as zrangebyscore from './zrangebyscore.js';
+import * as zrevrange from './zrevrange.js';
+import * as zrevrangebyscore from './zrevrangebyscore.js';
+import * as zrevrank from './zrevrank.js';
+import * as zrank from './zrank.js';
 import * as sqliteInfo from './sqlite-info.js';
 import * as cacheInfo from './cache-info.js';
 import * as memoryInfo from './memory-info.js';
@@ -119,6 +123,10 @@ const HANDLERS = new Map([
   ['ZSCORE', (e, a) => zscore.handleZscore(e, a)],
   ['ZRANGE', (e, a) => zrange.handleZrange(e, a)],
   ['ZRANGEBYSCORE', (e, a) => zrangebyscore.handleZrangebyscore(e, a)],
+  ['ZREVRANGE', (e, a) => zrevrange.handleZrevrange(e, a)],
+  ['ZREVRANGEBYSCORE', (e, a) => zrevrangebyscore.handleZrevrangebyscore(e, a)],
+  ['ZREVRANK', (e, a) => zrevrank.handleZrevrank(e, a)],
+  ['ZRANK', (e, a) => zrank.handleZrank(e, a)],
   ['SQLITE.INFO', (e, a) => sqliteInfo.handleSqliteInfo(e, a)],
   ['CACHE.INFO', (e, a) => cacheInfo.handleCacheInfo(e, a)],
   ['MEMORY.INFO', (e, a) => memoryInfo.handleMemoryInfo(e, a)],

package/src/commands/zrank.js

@@ -0,0 +1,18 @@
+/**
+ * ZRANK key member
+ * Returns the 0-based rank of member in the sorted set (low to high score).
+ * Returns null if key does not exist or member is not in the set.
+ */
+
+export function handleZrank(engine, args) {
+  if (!args || args.length < 2) {
+    return { error: 'ERR wrong number of arguments for \'ZRANK\' command' };
+  }
+  try {
+    const rank = engine.zrank(args[0], args[1]);
+    return rank;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/zrevrange.js

@@ -0,0 +1,27 @@
+/**
+ * ZREVRANGE key start stop [WITHSCORES]
+ * Same as ZRANGE but ordered from highest to lowest score (rank 0 = highest).
+ */
+
+export function handleZrevrange(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZREVRANGE\' command' };
+  }
+  let withScores = false;
+  for (let i = 3; i < args.length; i++) {
+    const a = (Buffer.isBuffer(args[i]) ? args[i].toString('utf8') : String(args[i])).toUpperCase();
+    if (a === 'WITHSCORES') withScores = true;
+  }
+  try {
+    const start = parseInt(String(args[1]), 10);
+    const stop = parseInt(String(args[2]), 10);
+    if (Number.isNaN(start) || Number.isNaN(stop)) {
+      return { error: 'ERR value is not an integer or out of range' };
+    }
+    const arr = engine.zrevrange(args[0], start, stop, { withScores });
+    return arr;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/zrevrangebyscore.js

@@ -0,0 +1,46 @@
+/**
+ * ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
+ * Same as ZRANGEBYSCORE but ordered from highest to lowest score.
+ * Note: Redis uses max min (first score is upper bound, second is lower bound).
+ */
+
+export function handleZrevrangebyscore(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZREVRANGEBYSCORE\' command' };
+  }
+  let withScores = false;
+  let limitOffset = null;
+  let limitCount = null;
+  const raw = args.slice(3);
+  for (let i = 0; i < raw.length; i++) {
+    const a = (Buffer.isBuffer(raw[i]) ? raw[i].toString('utf8') : String(raw[i])).toUpperCase();
+    if (a === 'WITHSCORES') {
+      withScores = true;
+    } else if (a === 'LIMIT' && i + 2 < raw.length) {
+      const off = parseInt(String(raw[i + 1]), 10);
+      const cnt = parseInt(String(raw[i + 2]), 10);
+      if (!Number.isNaN(off) && !Number.isNaN(cnt)) {
+        limitOffset = off;
+        limitCount = cnt;
+      }
+      i += 2;
+    }
+  }
+  try {
+    const max = parseFloat(String(args[1]));
+    const min = parseFloat(String(args[2]));
+    if (Number.isNaN(max) || Number.isNaN(min)) {
+      return { error: 'ERR value is not a valid float' };
+    }
+    const options = { withScores };
+    if (limitOffset != null && limitCount != null) {
+      options.offset = limitOffset;
+      options.limit = limitCount;
+    }
+    const arr = engine.zrevrangebyscore(args[0], max, min, options);
+    return arr;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/zrevrank.js

@@ -0,0 +1,18 @@
+/**
+ * ZREVRANK key member
+ * Returns the 0-based rank of member in the sorted set (high to low score).
+ * Returns null if key does not exist or member is not in the set.
+ */
+
+export function handleZrevrank(engine, args) {
+  if (!args || args.length < 2) {
+    return { error: 'ERR wrong number of arguments for \'ZREVRANK\' command' };
+  }
+  try {
+    const rank = engine.zrevrank(args[0], args[1]);
+    return rank;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/engine/engine.js

@@ -387,6 +387,30 @@ export function createEngine(opts = {}) {
       return zsets.rangeByRank(k, start, stop, { withScores: options.withScores });
     },
 
+    zrevrange(key, start, stop, options = {}) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return [];
+      expectZset(meta);
+      return zsets.rangeByRankReverse(k, start, stop, { withScores: options.withScores });
+    },
+
+    zrevrank(key, member) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return null;
+      expectZset(meta);
+      return zsets.rankReverse(k, asKey(member));
+    },
+
+    zrank(key, member) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return null;
+      expectZset(meta);
+      return zsets.rank(k, asKey(member));
+    },
+
     zrangebyscore(key, min, max, options = {}) {
       const k = asKey(key);
       const meta = getKeyMeta(key);
@@ -399,6 +423,18 @@ export function createEngine(opts = {}) {
       });
     },
 
+    zrevrangebyscore(key, max, min, options = {}) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return [];
+      expectZset(meta);
+      return zsets.rangeByScoreReverse(k, max, min, {
+        withScores: options.withScores,
+        offset: options.offset ?? 0,
+        limit: options.limit,
+      });
+    },
+
     type(key) {
       const meta = getKeyMeta(key);
       return typeName(meta);

package/src/storage/sqlite/zsets.js

@@ -36,12 +36,32 @@ export function createZsetsStorage(db, keys) {
      ORDER BY score ASC, member ASC
      LIMIT ? OFFSET ?`
   );
+  const rangeByRankReverseStmt = db.prepare(
+    `SELECT member, score FROM redis_zsets
+     WHERE key = ?
+     ORDER BY score DESC, member DESC
+     LIMIT ? OFFSET ?`
+  );
   const rangeByScoreStmt = db.prepare(
     `SELECT member, score FROM redis_zsets
      WHERE key = ? AND score >= ? AND score <= ?
      ORDER BY score ASC, member ASC
      LIMIT ? OFFSET ?`
   );
+  const rankReverseStmt = db.prepare(
+    `SELECT COUNT(*) AS n FROM redis_zsets
+     WHERE key = ? AND (score > ? OR (score = ? AND member > ?))`
+  );
+  const rankStmt = db.prepare(
+    `SELECT COUNT(*) AS n FROM redis_zsets
+     WHERE key = ? AND (score < ? OR (score = ? AND member < ?))`
+  );
+  const rangeByScoreReverseStmt = db.prepare(
+    `SELECT member, score FROM redis_zsets
+     WHERE key = ? AND score <= ? AND score >= ?
+     ORDER BY score DESC, member DESC
+     LIMIT ? OFFSET ?`
+  );
 
   return {
     /**
@@ -143,6 +163,34 @@ export function createZsetsStorage(db, keys) {
       return out;
     },
 
+    /**
+     * Range by rank in reverse order (ZREVRANGE). Rank 0 = highest score.
+     * Same start/stop semantics as rangeByRank; order is score DESC, member DESC.
+     * @param {Buffer} key
+     * @param {number} start 0-based inclusive (0 = highest score)
+     * @param {number} stop 0-based inclusive
+     * @param {{ withScores?: boolean }} options
+     * @returns {Buffer[] | Array<Buffer|string>} members or [member, score, ...]
+     */
+    rangeByRankReverse(key, start, stop, options = {}) {
+      const len = this.count(key);
+      if (len === 0) return [];
+      let s = start >= 0 ? start : Math.max(0, len + start);
+      let e = stop >= 0 ? stop : Math.max(0, len + stop);
+      if (s > e) return [];
+      s = Math.min(s, len - 1);
+      e = Math.min(e, len - 1);
+      const limit = e - s + 1;
+      const offset = s;
+      const rows = rangeByRankReverseStmt.all(key, limit, offset);
+      if (!options.withScores) return rows.map((r) => r.member);
+      const out = [];
+      for (const r of rows) {
+        out.push(r.member, formatScore(r.score));
+      }
+      return out;
+    },
+
     /**
      * Range by score (min/max inclusive). Order: score ASC, member ASC.
      * @param {Buffer} key
@@ -161,5 +209,52 @@ export function createZsetsStorage(db, keys) {
       }
       return out;
     },
+
+    /**
+     * Rank of member in reverse order (ZREVRANK). Rank 0 = highest score.
+     * Returns null if key does not exist or member not in set.
+     * @param {Buffer} key
+     * @param {Buffer} member
+     * @returns {number | null} 0-based rank or null
+     */
+    rankReverse(key, member) {
+      const scoreRow = scoreStmt.get(key, member);
+      if (scoreRow == null) return null;
+      const row = rankReverseStmt.get(key, scoreRow.score, scoreRow.score, member);
+      return row ? row.n : 0;
+    },
+
+    /**
+     * Rank of member in ascending order (ZRANK). Rank 0 = lowest score.
+     * Returns null if key does not exist or member not in set.
+     * @param {Buffer} key
+     * @param {Buffer} member
+     * @returns {number | null} 0-based rank or null
+     */
+    rank(key, member) {
+      const scoreRow = scoreStmt.get(key, member);
+      if (scoreRow == null) return null;
+      const row = rankStmt.get(key, scoreRow.score, scoreRow.score, member);
+      return row ? row.n : 0;
+    },
+
+    /**
+     * Range by score in reverse order (ZREVRANGEBYSCORE). max/min inclusive, order score DESC, member DESC.
+     * @param {Buffer} key
+     * @param {number} max
+     * @param {number} min
+     * @param {{ withScores?: boolean, limit?: number, offset?: number }} options
+     */
+    rangeByScoreReverse(key, max, min, options = {}) {
+      const limit = options.limit ?? -1;
+      const offset = options.offset ?? 0;
+      const rows = rangeByScoreReverseStmt.all(key, max, min, limit < 0 ? 1e9 : limit, offset);
+      if (!options.withScores) return rows.map((r) => r.member);
+      const out = [];
+      for (const r of rows) {
+        out.push(r.member, formatScore(r.score));
+      }
+      return out;
+    },
   };
 }

package/test/integration/zsets.test.js

@@ -51,6 +51,74 @@ describe('ZSET integration', () => {
     assert.equal(arr[3].toString('utf8'), '2');
   });
 
+  it('ZREVRANGE returns order highest to lowest and supports WITHSCORES', async () => {
+    await sendCommand(port, argv('ZADD', 'zrev', '1', 'a', '2', 'b', '3', 'c'));
+    const rev = await sendCommand(port, argv('ZREVRANGE', 'zrev', '0', '-1'));
+    const arr = tryParseValue(rev, 0).value;
+    assert.equal(arr.length, 3);
+    assert.equal(arr[0].toString('utf8'), 'c');
+    assert.equal(arr[1].toString('utf8'), 'b');
+    assert.equal(arr[2].toString('utf8'), 'a');
+
+    const withScores = await sendCommand(port, argv('ZREVRANGE', 'zrev', '0', '30', 'WITHSCORES'));
+    const withArr = tryParseValue(withScores, 0).value;
+    assert.equal(withArr.length, 6);
+    assert.equal(withArr[0].toString('utf8'), 'c');
+    assert.equal(withArr[1].toString('utf8'), '3');
+    assert.equal(withArr[2].toString('utf8'), 'b');
+    assert.equal(withArr[3].toString('utf8'), '2');
+  });
+
+  it('ZREVRANK returns 0-based rank high-to-low and nil when missing', async () => {
+    await sendCommand(port, argv('ZADD', 'zrevrank', '1', 'a', '2', 'b', '3', 'c'));
+    const rankC = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'c'));
+    assert.equal(tryParseValue(rankC, 0).value, 0);
+    const rankB = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'b'));
+    assert.equal(tryParseValue(rankB, 0).value, 1);
+    const rankA = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'a'));
+    assert.equal(tryParseValue(rankA, 0).value, 2);
+
+    const noMember = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'x'));
+    assert.ok(noMember.toString('ascii').startsWith('$-1'));
+    const noKey = await sendCommand(port, argv('ZREVRANK', 'nokey', 'a'));
+    assert.ok(noKey.toString('ascii').startsWith('$-1'));
+  });
+
+  it('ZRANK returns 0-based rank low-to-high and nil when missing', async () => {
+    await sendCommand(port, argv('ZADD', 'zrank', '1', 'a', '2', 'b', '3', 'c'));
+    const rankA = await sendCommand(port, argv('ZRANK', 'zrank', 'a'));
+    assert.equal(tryParseValue(rankA, 0).value, 0);
+    const rankB = await sendCommand(port, argv('ZRANK', 'zrank', 'b'));
+    assert.equal(tryParseValue(rankB, 0).value, 1);
+    const rankC = await sendCommand(port, argv('ZRANK', 'zrank', 'c'));
+    assert.equal(tryParseValue(rankC, 0).value, 2);
+
+    const noMember = await sendCommand(port, argv('ZRANK', 'zrank', 'x'));
+    assert.ok(noMember.toString('ascii').startsWith('$-1'));
+  });
+
+  it('ZREVRANGEBYSCORE returns score range high-to-low and supports WITHSCORES and LIMIT', async () => {
+    await sendCommand(port, argv('ZADD', 'zrevscore', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+    const rev = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zrevscore', '4', '2'));
+    const arr = tryParseValue(rev, 0).value;
+    assert.equal(arr.length, 3);
+    assert.equal(arr[0].toString('utf8'), 'd');
+    assert.equal(arr[1].toString('utf8'), 'c');
+    assert.equal(arr[2].toString('utf8'), 'b');
+
+    const withScores = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zrevscore', '10', '0', 'WITHSCORES'));
+    const withArr = tryParseValue(withScores, 0).value;
+    assert.equal(withArr.length, 8);
+    assert.equal(withArr[0].toString('utf8'), 'd');
+    assert.equal(withArr[1].toString('utf8'), '4');
+
+    const limitReply = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zrevscore', '10', '0', 'LIMIT', '1', '2'));
+    const limited = tryParseValue(limitReply, 0).value;
+    assert.equal(limited.length, 2);
+    assert.equal(limited[0].toString('utf8'), 'c');
+    assert.equal(limited[1].toString('utf8'), 'b');
+  });
+
   it('ZRANGE negative indices and start > stop', async () => {
     await sendCommand(port, argv('ZADD', 'z4', '1', 'a', '2', 'b', '3', 'c'));
     const last = await sendCommand(port, argv('ZRANGE', 'z4', '-1', '-1'));