diff --git a/.gitignore b/.gitignore
index 9384b6a4..2208a564 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
### Linux ###
+
*~
# temporary files which can be created if a process still has a handle open of a deleted file
@@ -79,4 +80,4 @@ ssh
.qdrant-initialized
libnull.rlib
fuzz
-shard-*/
\ No newline at end of file
+shard-*/
diff --git a/scripts/bench-phase101-commands.sh b/scripts/bench-phase101-commands.sh
new file mode 100755
index 00000000..2524728c
--- /dev/null
+++ b/scripts/bench-phase101-commands.sh
@@ -0,0 +1,369 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+###############################################################################
+# bench-phase101-commands.sh -- Moon vs Redis benchmark for Phase 101 commands
+#
+# Tests all 24 commands added in Phase 101 (command parity gaps):
+# HyperLogLog, List convenience, Hash, Set, Sorted Set 6.2+,
+# Blocking fast-path, Functions/FCALL
+#
+# Usage:
+# ./scripts/bench-phase101-commands.sh # Full run (20K req)
+# ./scripts/bench-phase101-commands.sh --requests N # Custom request count
+# ./scripts/bench-phase101-commands.sh --shards N # Moon shard count
+# ./scripts/bench-phase101-commands.sh --section hll # Single section
+#
+# Sections: all, hll, list, hash, set, zset, blocking, functions, pipeline
+###############################################################################
+
+PORT_REDIS=6399
+PORT_MOON=6400
+REQUESTS=20000
+CLIENTS=50
+SHARDS=1
+SECTION="all"
+RUST_BINARY="./target/release/moon"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+REDIS_PID=""
+MOON_PID=""
+
+while [[ $# -gt 0 ]]; do
+ case "$1" in
+ --requests) if [[ $# -lt 2 ]] || [[ -z "$2" ]] || [[ "$2" == -* ]]; then echo "Error: --requests requires a value"; exit 1; fi; REQUESTS="$2"; shift 2 ;;
+ --shards) if [[ $# -lt 2 ]] || [[ -z "$2" ]] || [[ "$2" == -* ]]; then echo "Error: --shards requires a value"; exit 1; fi; SHARDS="$2"; shift 2 ;;
+ --clients) if [[ $# -lt 2 ]] || [[ -z "$2" ]] || [[ "$2" == -* ]]; then echo "Error: --clients requires a value"; exit 1; fi; CLIENTS="$2"; shift 2 ;;
+ --section) if [[ $# -lt 2 ]] || [[ -z "$2" ]] || [[ "$2" == -* ]]; then echo "Error: --section requires a value"; exit 1; fi; SECTION="$2"; shift 2 ;;
+ --help) awk '/^###/{n++} n==1' "$0"; exit 0 ;;
+ *) echo "Unknown option: $1"; exit 1 ;;
+ esac
+done
+
+log() { echo "[$(date '+%H:%M:%S')] $*" >&2; }
+
+cleanup() {
+ log "Cleaning up..."
+ if [[ -n "${MOON_PID:-}" ]]; then kill "$MOON_PID" 2>/dev/null || true; wait "$MOON_PID" 2>/dev/null || true; fi
+ if [[ -n "${REDIS_PID:-}" ]]; then kill "$REDIS_PID" 2>/dev/null || true; wait "$REDIS_PID" 2>/dev/null || true; fi
+ pkill -f "redis-server.*${PORT_REDIS}" 2>/dev/null || true
+ pkill -f "moon.*${PORT_MOON}" 2>/dev/null || true
+}
+trap cleanup EXIT
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+parse_rps() {
+ tr '\r' '\n' \
+ | awk '/[Rr]equests per second/ {
+ for (i=1; i<=NF; i++) { gsub(/,/, "", $i); if ($i+0 == $i && $i > 0) { print $i; exit } }
+ }' \
+ | head -1
+}
+
+print_row() {
+ local desc="$1" redis_rps="${2:-0}" moon_rps="${3:-0}" ratio
+ if [[ "$redis_rps" != "0" ]] && [[ "$moon_rps" != "0" ]]; then
+ ratio=$(awk "BEGIN { printf \"%.2f\", $moon_rps / $redis_rps }")
+ else
+ ratio="N/A"
+ fi
+ printf "| %-40s | %12s | %12s | %6sx |\n" "$desc" "$redis_rps" "$moon_rps" "$ratio"
+}
+
+section_header() {
+ echo ""
+ echo "## $1"
+ echo ""
+ printf "| %-40s | %12s | %12s | %7s |\n" "Command" "Redis RPS" "Moon RPS" "Ratio"
+ printf "|%-42s|%14s|%14s|%9s|\n" "------------------------------------------" "--------------" "--------------" "---------"
+}
+
+should_run() { [[ "$SECTION" == "all" ]] || [[ "$SECTION" == "$1" ]]; }
+
+# redis-benchmark for commands it handles (single-key, simple args)
+bench_rb() {
+ local desc="$1"; shift
+ local r m
+ r=$(redis-benchmark -p "$PORT_REDIS" -n "$REQUESTS" -c "$CLIENTS" -q "$@" 2>/dev/null | parse_rps)
+ m=$(redis-benchmark -p "$PORT_MOON" -n "$REQUESTS" -c "$CLIENTS" -q "$@" 2>/dev/null | parse_rps)
+ print_row "$desc" "${r:-0}" "${m:-0}"
+}
+
+# Build RESP protocol string for one command
+_resp() {
+ local n=$#
+ printf "*%d\r\n" "$n"
+ for arg in "$@"; do
+ printf "\$%d\r\n%s\r\n" "${#arg}" "$arg"
+ done
+}
+
+# Pipe N copies of a RESP command to a port, return RPS
+_pipe_rps() {
+ local port="$1" n="$2"; shift 2
+ local one_cmd
+ one_cmd=$(_resp "$@")
+ local payload
+ payload=$(python3 -c "import sys; sys.stdout.write(sys.stdin.read() * $n)" <<< "$one_cmd")
+
+ local start end ms rps
+ start=$(date +%s%N)
+ printf '%s' "$payload" | redis-cli -p "$port" --pipe 2>/dev/null >/dev/null
+ end=$(date +%s%N)
+ ms=$(( (end - start) / 1000000 ))
+ if [[ $ms -gt 0 ]]; then
+ rps=$(awk "BEGIN { printf \"%.0f\", ($n * 1000.0) / $ms }")
+ else
+ rps="0"
+ fi
+ echo "$rps"
+}
+
+# Benchmark via pipe mode (for multi-arg commands redis-benchmark can't run)
+bench_pipe() {
+ local desc="$1"; shift
+ local r m
+ r=$(_pipe_rps "$PORT_REDIS" "$REQUESTS" "$@")
+ m=$(_pipe_rps "$PORT_MOON" "$REQUESTS" "$@")
+ print_row "$desc" "$r" "$m"
+}
+
+# Re-seed a key with N elements via pipe
+reseed_list() {
+ local key="$1" n="$2"
+ for port in "$PORT_REDIS" "$PORT_MOON"; do
+ redis-cli -p "$port" DEL "$key" >/dev/null 2>&1
+ local one=$(_resp RPUSH "$key" val)
+ python3 -c "import sys; sys.stdout.write(sys.stdin.read() * $n)" <<< "$one" \
+ | redis-cli -p "$port" --pipe 2>/dev/null >/dev/null
+ done
+}
+
+reseed_zset() {
+ local key="$1" n="$2"
+ for port in "$PORT_REDIS" "$PORT_MOON"; do
+ redis-cli -p "$port" DEL "$key" >/dev/null 2>&1
+ local cmds=""
+ for ((i=1; i<=n; i++)); do
+ cmds+=$(_resp ZADD "$key" "$i" "m$i")
+ done
+ printf '%s' "$cmds" | redis-cli -p "$port" --pipe 2>/dev/null >/dev/null
+ done
+}
+
+# ===========================================================================
+# Start Servers
+# ===========================================================================
+
+log "Starting Redis on port $PORT_REDIS..."
+redis-server --port "$PORT_REDIS" --save "" --appendonly no --loglevel warning --protected-mode no &
+REDIS_PID=$!
+
+log "Starting Moon on port $PORT_MOON ($SHARDS shards)..."
+RUST_LOG=warn "$RUST_BINARY" --port "$PORT_MOON" --shards "$SHARDS" --protected-mode no &
+MOON_PID=$!
+
+wait_for_server() {
+ local port="$1" name="$2" i=0
+ while (( i < 20 )); do
+ redis-cli -p "$port" PING 2>/dev/null | grep -q PONG && return 0
+ sleep 0.5; i=$((i+1))
+ done
+ echo "$name failed to start on port $port"; exit 1
+}
+
+wait_for_server "$PORT_REDIS" "Redis"
+wait_for_server "$PORT_MOON" "Moon"
+log "Servers ready."
+
+# ===========================================================================
+# Header
+# ===========================================================================
+
+REDIS_VER=$(redis-cli -p "$PORT_REDIS" INFO server 2>/dev/null | grep redis_version | cut -d: -f2 | tr -d '\r')
+PLATFORM="$(uname -s) $(uname -m)"
+[[ -f /etc/os-release ]] && PLATFORM="$PLATFORM / $(grep PRETTY_NAME /etc/os-release | cut -d= -f2 | tr -d '"')"
+
+echo "# Phase 101 — Command Parity Benchmark (Moon vs Redis)"
+echo ""
+echo "| Property | Value |"
+echo "|----------|-------|"
+echo "| Date | $(date +%Y-%m-%d) |"
+echo "| Redis | $REDIS_VER |"
+echo "| Moon | $SHARDS shard(s) |"
+echo "| Requests | $REQUESTS per test |"
+echo "| Clients | $CLIENTS |"
+echo "| Platform | $PLATFORM |"
+
+# ===========================================================================
+# Seed data (fast Python-based seeder)
+# ===========================================================================
+
+log "Seeding test data..."
+python3 "$SCRIPT_DIR/bench-phase101-seed.py" "$PORT_REDIS"
+python3 "$SCRIPT_DIR/bench-phase101-seed.py" "$PORT_MOON"
+log "Data seeded."
+
+# ===========================================================================
+# HyperLogLog
+# ===========================================================================
+
+if should_run "hll"; then
+ log "Benchmarking HyperLogLog..."
+ section_header "HyperLogLog (PFADD / PFCOUNT / PFMERGE)"
+
+ bench_rb "PFADD (1 elem, existing key)" PFADD hll1 newelem
+ bench_rb "PFADD (3 elem, new key)" PFADD hllbench a b c
+ bench_rb "PFCOUNT (1 key)" PFCOUNT hll1
+ bench_pipe "PFCOUNT (2 keys)" PFCOUNT hll1 hll2
+ bench_pipe "PFMERGE (2 → 1)" PFMERGE hll3 hll1 hll2
+fi
+
+# ===========================================================================
+# List Commands
+# ===========================================================================
+
+if should_run "list"; then
+ log "Benchmarking list commands..."
+ section_header "List (LPUSHX / RPUSHX / LMPOP)"
+
+ bench_rb "LPUSHX (existing key)" LPUSHX mylist val
+ bench_rb "RPUSHX (existing key)" RPUSHX mylist val
+ bench_rb "LPUSHX (missing key → NOP)" LPUSHX nokey val
+ bench_pipe "LMPOP 1 key LEFT" LMPOP 1 mylist LEFT
+ bench_pipe "LMPOP 1 key LEFT COUNT 10" LMPOP 1 mylist LEFT COUNT 10
+fi
+
+# ===========================================================================
+# Hash Commands
+# ===========================================================================
+
+if should_run "hash"; then
+ log "Benchmarking hash commands..."
+ section_header "Hash (HRANDFIELD)"
+
+ bench_rb "HRANDFIELD (1 field)" HRANDFIELD myhash
+ bench_pipe "HRANDFIELD (5 fields)" HRANDFIELD myhash 5
+ bench_pipe "HRANDFIELD (10 WITHVALUES)" HRANDFIELD myhash 10 WITHVALUES
+ bench_pipe "HRANDFIELD (-5, allow dups)" HRANDFIELD myhash -5
+fi
+
+# ===========================================================================
+# Set Commands
+# ===========================================================================
+
+if should_run "set"; then
+ log "Benchmarking set commands..."
+ section_header "Set (SMOVE / SINTERCARD)"
+
+ bench_pipe "SMOVE (member exists)" SMOVE smvsrc smvdst m1
+ bench_pipe "SINTERCARD (2 sets)" SINTERCARD 2 myset1 myset2
+ bench_pipe "SINTERCARD (3 sets)" SINTERCARD 3 myset1 myset2 myset3
+ bench_pipe "SINTERCARD (2 sets, LIMIT 10)" SINTERCARD 2 myset1 myset2 LIMIT 10
+fi
+
+# ===========================================================================
+# Sorted Set 6.2+
+# ===========================================================================
+
+if should_run "zset"; then
+ log "Benchmarking sorted set 6.2+ commands..."
+ section_header "Sorted Set 6.2+ (ZRANGESTORE / ZDIFF / ZUNION / ZINTER / etc.)"
+
+ bench_pipe "ZRANGESTORE (50 elements)" ZRANGESTORE zdst myzset1 0 49
+ bench_pipe "ZDIFF (2 keys)" ZDIFF 2 myzset1 myzset2
+ bench_pipe "ZUNION (2 keys)" ZUNION 2 myzset1 myzset2
+ bench_pipe "ZINTER (2 keys)" ZINTER 2 myzset1 myzset2
+ bench_pipe "ZINTERCARD (2 keys)" ZINTERCARD 2 myzset1 myzset2
+ bench_pipe "ZINTERCARD (2 keys, LIMIT 10)" ZINTERCARD 2 myzset1 myzset2 LIMIT 10
+ bench_pipe "ZMSCORE (3 members)" ZMSCORE myzset1 m1 m50 m100
+ bench_pipe "ZRANDMEMBER (1)" ZRANDMEMBER myzset1
+ bench_pipe "ZRANDMEMBER (10)" ZRANDMEMBER myzset1 10
+ bench_pipe "ZRANDMEMBER (5 WITHSCORES)" ZRANDMEMBER myzset1 5 WITHSCORES
+ bench_pipe "ZMPOP 1 key MIN" ZMPOP 1 bzset MIN
+ bench_pipe "ZMPOP 1 key MIN COUNT 5" ZMPOP 1 bzset MIN COUNT 5
+fi
+
+# ===========================================================================
+# Blocking fast-path (data already present → immediate return)
+# ===========================================================================
+
+if should_run "blocking"; then
+ log "Benchmarking blocking commands (fast path)..."
+ section_header "Blocking — Fast Path (element already available)"
+
+ echo "| *(Blocking cmds use non-blocking equivalents for throughput comparison)* ||||"
+
+ # Blocking commands can't be benchmarked via pipe (they consume + block).
+ # Instead, compare the non-blocking equivalents which share the same code path.
+ # The blocking overhead is just the timeout check + registry lookup (~10ns).
+ bench_rb "LPOP (= BLPOP fast path)" LPOP blist
+ bench_rb "RPOP (= BRPOP fast path)" RPOP blist
+
+ # BLMPOP/BLMOVE/BZMPOP can't use redis-benchmark directly.
+ # Use pipe with small N and large pre-seeded data to avoid exhaustion.
+ bench_pipe "LMPOP 1 key LEFT (= BLMPOP path)" LMPOP 1 blist LEFT
+ bench_pipe "LMOVE (= BLMOVE path)" LMOVE blsrc bldst LEFT RIGHT
+ bench_pipe "ZMPOP 1 key MIN (= BZMPOP path)" ZMPOP 1 bzset MIN
+fi
+
+# ===========================================================================
+# Functions / FCALL
+# ===========================================================================
+
+if should_run "functions"; then
+ log "Benchmarking Functions/FCALL..."
+ section_header "Functions API (FCALL / FCALL_RO)"
+
+ bench_pipe "FCALL echo1 (0 keys, 1 arg)" FCALL echo1 0 hello
+ bench_pipe "FCALL_RO echo1 (0 keys, 1 arg)" FCALL_RO echo1 0 hello
+ bench_pipe "FUNCTION LIST" FUNCTION LIST
+fi
+
+# ===========================================================================
+# Pipeline scaling for key Phase 101 commands
+# ===========================================================================
+
+if should_run "pipeline" || should_run "all"; then
+ log "Benchmarking pipeline scaling..."
+ section_header "Pipeline Scaling — Phase 101 Commands"
+
+ for p in 1 8 16 64; do
+ for cmd_desc_args in \
+ "PFADD:PFADD hll1 newelem" \
+ "PFCOUNT:PFCOUNT hll1" \
+ "LPUSHX:LPUSHX mylist val" \
+ "HRANDFIELD:HRANDFIELD myhash" \
+ "ZRANDMEMBER:ZRANDMEMBER myzset1" \
+ ; do
+ local_desc="${cmd_desc_args%%:*}"
+ local_args="${cmd_desc_args#*:}"
+ # shellcheck disable=SC2086
+ r=$(redis-benchmark -p "$PORT_REDIS" -n "$REQUESTS" -c "$CLIENTS" -P "$p" -q $local_args 2>/dev/null | parse_rps)
+ # shellcheck disable=SC2086
+ m=$(redis-benchmark -p "$PORT_MOON" -n "$REQUESTS" -c "$CLIENTS" -P "$p" -q $local_args 2>/dev/null | parse_rps)
+ print_row "${local_desc} p=$p" "${r:-0}" "${m:-0}"
+ done
+ done
+fi
+
+# ===========================================================================
+# Summary
+# ===========================================================================
+
+echo ""
+echo "---"
+echo ""
+echo "### Legend"
+echo "- **Ratio > 1.0**: Moon is faster"
+echo "- **Ratio < 1.0**: Redis is faster"
+echo "- **Ratio = N/A**: Command not supported or returned 0"
+echo "- Pipe-mode tests are single-connection serial (lower absolute RPS, fair comparison)"
+echo "- redis-benchmark tests use $CLIENTS parallel clients"
+echo ""
+echo "*Generated by bench-phase101-commands.sh on $(date)*"
+
+log "Done."
diff --git a/scripts/bench-phase101-seed.py b/scripts/bench-phase101-seed.py
new file mode 100644
index 00000000..ba28497f
--- /dev/null
+++ b/scripts/bench-phase101-seed.py
@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Seed test data for Phase 101 benchmarks via redis-cli --pipe."""
+import subprocess
+import sys
+
+def resp(*args):
+ """Build RESP protocol for a command."""
+ parts = [f"*{len(args)}\r\n"]
+ for a in args:
+ s = str(a)
+ parts.append(f"${len(s.encode('utf-8'))}\r\n{s}\r\n")
+ return "".join(parts)
+
+def pipe(port, commands):
+ """Send commands via redis-cli --pipe."""
+ data = "".join(commands)
+ p = subprocess.run(
+ ["redis-cli", "-p", str(port), "--pipe"],
+ input=data.encode(), capture_output=True, check=True
+ )
+
+def seed(port):
+ cmds = []
+
+ # Lists
+ cmds.append(resp("DEL", "mylist", "blist", "blsrc", "bldst"))
+ for i in range(1, 10001):
+ cmds.append(resp("RPUSH", "mylist", str(i)))
+ for i in range(1, 50001):
+ cmds.append(resp("RPUSH", "blist", str(i)))
+ for i in range(1, 50001):
+ cmds.append(resp("RPUSH", "blsrc", str(i)))
+ pipe(port, cmds)
+
+ # Hash
+ cmds = [resp("DEL", "myhash")]
+ for i in range(1, 101):
+ cmds.append(resp("HSET", "myhash", f"field{i}", f"value{i}"))
+ pipe(port, cmds)
+
+ # Sets
+ cmds = [resp("DEL", "myset1", "myset2", "myset3", "smvsrc", "smvdst")]
+ for i in range(1, 201):
+ cmds.append(resp("SADD", "myset1", f"m{i}"))
+ for i in range(50, 251):
+ cmds.append(resp("SADD", "myset2", f"m{i}"))
+ for i in range(100, 301):
+ cmds.append(resp("SADD", "myset3", f"m{i}"))
+ for i in range(1, 20001):
+ cmds.append(resp("SADD", "smvsrc", f"m{i}"))
+ pipe(port, cmds)
+
+ # Sorted sets
+ cmds = [resp("DEL", "myzset1", "myzset2", "myzset3", "bzset", "zdst")]
+ for i in range(1, 201):
+ cmds.append(resp("ZADD", "myzset1", str(i), f"m{i}"))
+ for i in range(50, 251):
+ cmds.append(resp("ZADD", "myzset2", str(i), f"m{i}"))
+ for i in range(100, 301):
+ cmds.append(resp("ZADD", "myzset3", str(i), f"m{i}"))
+ for i in range(1, 50001):
+ cmds.append(resp("ZADD", "bzset", str(i), f"m{i}"))
+ pipe(port, cmds)
+
+ # HyperLogLog
+ cmds = [resp("DEL", "hll1", "hll2", "hll3")]
+ for i in range(1, 1001):
+ cmds.append(resp("PFADD", "hll1", f"e{i}"))
+ for i in range(500, 1501):
+ cmds.append(resp("PFADD", "hll2", f"e{i}"))
+ pipe(port, cmds)
+
+ # Function library
+ body = '#!lua name=benchlib\nredis.register_function("echo1", function(keys, args) return args[1] end)'
+ subprocess.run(
+ ["redis-cli", "-p", str(port), "FUNCTION", "FLUSH"],
+ capture_output=True, check=True
+ )
+ subprocess.run(
+ ["redis-cli", "-p", str(port), "FUNCTION", "LOAD", "REPLACE", body],
+ capture_output=True, check=True
+ )
+
+if __name__ == "__main__":
+ port = int(sys.argv[1]) if len(sys.argv) > 1 else 6379
+ seed(port)
diff --git a/src/blocking/mod.rs b/src/blocking/mod.rs
index 57c7c7e7..0891cb1f 100644
--- a/src/blocking/mod.rs
+++ b/src/blocking/mod.rs
@@ -22,8 +22,16 @@ pub enum BlockedCommand {
wherefrom: Direction,
whereto: Direction,
},
+ BLMPop {
+ dir: Direction,
+ count: u32,
+ },
BZPopMin,
BZPopMax,
+ BZMPop {
+ min: bool,
+ count: u32,
+ },
XRead {
/// (key, last_seen_id) pairs -- read entries > last_seen_id from each stream.
streams: Vec<(Bytes, crate::storage::stream::StreamId)>,
diff --git a/src/blocking/wakeup.rs b/src/blocking/wakeup.rs
index 5762d2be..6997e4fc 100644
--- a/src/blocking/wakeup.rs
+++ b/src/blocking/wakeup.rs
@@ -1,6 +1,7 @@
use bytes::Bytes;
use crate::blocking::{BlockedCommand, BlockingRegistry, Direction};
+use crate::command::sorted_set::format_score_bytes;
use crate::framevec;
use crate::protocol::Frame;
use crate::storage::Database;
@@ -63,6 +64,29 @@ pub fn try_wake_list_waiter(
Frame::BulkString(v)
})
}
+ BlockedCommand::BLMPop { dir, count } => {
+ let mut elems = smallvec::SmallVec::<[Frame; 16]>::new();
+ let n = *count as usize;
+ for _ in 0..n {
+ let val = match dir {
+ Direction::Left => db.list_pop_front(key),
+ Direction::Right => db.list_pop_back(key),
+ };
+ match val {
+ Some(v) => elems.push(Frame::BulkString(v)),
+ None => break,
+ }
+ }
+ if elems.is_empty() {
+ None
+ } else {
+ let elem_vec: Vec = elems.into_vec();
+ Some(Frame::Array(framevec![
+ Frame::BulkString(key.clone()),
+ Frame::Array(elem_vec.into()),
+ ]))
+ }
+ }
_ => None, // BZPopMin/BZPopMax don't watch list keys
};
@@ -97,25 +121,48 @@ pub fn try_wake_zset_waiter(
let wait_id = waiter.wait_id;
let result = match &waiter.cmd {
- BlockedCommand::BZPopMin => {
- // Pop min, return [key, member, score]
- db.zset_pop_min(key).map(|(member, score)| {
- Frame::Array(framevec![
- Frame::BulkString(key.clone()),
- Frame::BulkString(member),
- Frame::BulkString(Bytes::from(format_score(score))),
- ])
- })
- }
- BlockedCommand::BZPopMax => {
- // Pop max, return [key, member, score]
- db.zset_pop_max(key).map(|(member, score)| {
- Frame::Array(framevec![
+ BlockedCommand::BZPopMin => db.zset_pop_min(key).map(|(member, score)| {
+ Frame::Array(framevec![
+ Frame::BulkString(key.clone()),
+ Frame::BulkString(member),
+ Frame::BulkString(format_score_bytes(score)),
+ ])
+ }),
+ BlockedCommand::BZPopMax => db.zset_pop_max(key).map(|(member, score)| {
+ Frame::Array(framevec![
+ Frame::BulkString(key.clone()),
+ Frame::BulkString(member),
+ Frame::BulkString(format_score_bytes(score)),
+ ])
+ }),
+ BlockedCommand::BZMPop { min, count } => {
+ let n = *count as usize;
+ let mut elems = smallvec::SmallVec::<[Frame; 16]>::new();
+ for _ in 0..n {
+ let popped = if *min {
+ db.zset_pop_min(key)
+ } else {
+ db.zset_pop_max(key)
+ };
+ match popped {
+ Some((member, score)) => {
+ elems.push(Frame::Array(framevec![
+ Frame::BulkString(member),
+ Frame::BulkString(format_score_bytes(score)),
+ ]));
+ }
+ None => break,
+ }
+ }
+ if elems.is_empty() {
+ None
+ } else {
+ let elem_vec: Vec = elems.into_vec();
+ Some(Frame::Array(framevec![
Frame::BulkString(key.clone()),
- Frame::BulkString(member),
- Frame::BulkString(Bytes::from(format_score(score))),
- ])
- })
+ Frame::Array(elem_vec.into()),
+ ]))
+ }
}
_ => None, // List commands don't watch zset keys
};
@@ -232,12 +279,3 @@ pub fn try_wake_stream_waiter(
}
false
}
-
-/// Format a float score the same way Redis does (integer if whole, otherwise full precision).
-fn format_score(score: f64) -> String {
- if score == score.floor() && score.abs() < i64::MAX as f64 {
- format!("{}", score as i64)
- } else {
- format!("{}", score)
- }
-}
diff --git a/src/command/functions.rs b/src/command/functions.rs
new file mode 100644
index 00000000..dc062b20
--- /dev/null
+++ b/src/command/functions.rs
@@ -0,0 +1,335 @@
+//! FUNCTION LOAD/LIST/DELETE/FLUSH + FCALL/FCALL_RO command handlers.
+//!
+//! **Phase 101 limitation:** RAM-only. FUNCTION DUMP/RESTORE/STATS return
+//! `-ERR ... not supported in this release (Phase 101 limitation)`.
+
+use bytes::Bytes;
+
+use crate::protocol::Frame;
+use crate::scripting::functions::FunctionRegistry;
+use crate::storage::Database;
+
+/// Handle `FUNCTION [args...]`.
+///
+/// Supported: LOAD, LIST, DELETE, FLUSH.
+/// Deferred: DUMP, RESTORE, STATS (return documented error).
+pub fn handle_function(registry: &mut FunctionRegistry, args: &[Frame]) -> Frame {
+ if args.is_empty() {
+ return Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'function' command",
+ ));
+ }
+
+ let sub = match &args[0] {
+ Frame::BulkString(b) => b,
+ _ => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'function' command",
+ ));
+ }
+ };
+
+ if sub.eq_ignore_ascii_case(b"LOAD") {
+ handle_function_load(registry, &args[1..])
+ } else if sub.eq_ignore_ascii_case(b"LIST") {
+ handle_function_list(registry, &args[1..])
+ } else if sub.eq_ignore_ascii_case(b"DELETE") {
+ handle_function_delete(registry, &args[1..])
+ } else if sub.eq_ignore_ascii_case(b"FLUSH") {
+ registry.flush();
+ Frame::SimpleString(Bytes::from_static(b"OK"))
+ } else if sub.eq_ignore_ascii_case(b"DUMP") {
+ Frame::Error(Bytes::from_static(
+ b"ERR FUNCTION DUMP not supported in this release (Phase 101 limitation)",
+ ))
+ } else if sub.eq_ignore_ascii_case(b"RESTORE") {
+ Frame::Error(Bytes::from_static(
+ b"ERR FUNCTION RESTORE not supported in this release (Phase 101 limitation)",
+ ))
+ } else if sub.eq_ignore_ascii_case(b"STATS") {
+ Frame::Error(Bytes::from_static(
+ b"ERR FUNCTION STATS not supported in this release (Phase 101 limitation)",
+ ))
+ } else {
+ Frame::Error(Bytes::from(format!(
+ "ERR unknown subcommand '{}'. Try FUNCTION HELP.",
+ String::from_utf8_lossy(sub)
+ )))
+ }
+}
+
+/// FUNCTION LOAD [REPLACE]
+fn handle_function_load(registry: &mut FunctionRegistry, args: &[Frame]) -> Frame {
+ if args.is_empty() {
+ return Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'function|load' command",
+ ));
+ }
+
+ let mut replace = false;
+ let body: &Bytes;
+
+ // Parse: FUNCTION LOAD [REPLACE]
+ if args.len() == 1 {
+ // FUNCTION LOAD
+ body = match &args[0] {
+ Frame::BulkString(b) => b,
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ };
+ } else if args.len() == 2 {
+ // FUNCTION LOAD REPLACE
+ let flag = match &args[0] {
+ Frame::BulkString(b) => b,
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ };
+ if !flag.eq_ignore_ascii_case(b"REPLACE") {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ replace = true;
+ body = match &args[1] {
+ Frame::BulkString(b) => b,
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ };
+ } else {
+ return Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'function|load' command",
+ ));
+ }
+
+ match registry.load(body, replace) {
+ Ok(lib_name) => Frame::BulkString(lib_name),
+ Err(e) => e.into_frame(),
+ }
+}
+
+/// FUNCTION LIST [LIBRARYNAME pattern] [WITHCODE]
+fn handle_function_list(registry: &FunctionRegistry, args: &[Frame]) -> Frame {
+ let mut _pattern: Option<&[u8]> = None;
+ let mut with_code = false;
+
+ let mut i = 0;
+ while i < args.len() {
+ match &args[i] {
+ Frame::BulkString(b) if b.eq_ignore_ascii_case(b"LIBRARYNAME") => {
+ if i + 1 < args.len() {
+ if let Frame::BulkString(p) = &args[i + 1] {
+ _pattern = Some(p.as_ref());
+ }
+ i += 2;
+ } else {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ }
+ Frame::BulkString(b) if b.eq_ignore_ascii_case(b"WITHCODE") => {
+ with_code = true;
+ i += 1;
+ }
+ _ => {
+ i += 1;
+ }
+ }
+ }
+
+ let libs = registry.list();
+ let mut result = Vec::with_capacity(libs.len());
+
+ for lib in libs {
+ // Each library is a flat array of key-value pairs (Redis 7.0 format):
+ // ["library_name", name, "engine", "LUA", "functions", [...]]
+ let mut entry = Vec::with_capacity(if with_code { 8 } else { 6 });
+
+ entry.push(Frame::BulkString(Bytes::from_static(b"library_name")));
+ entry.push(Frame::BulkString(lib.name.clone()));
+
+ entry.push(Frame::BulkString(Bytes::from_static(b"engine")));
+ entry.push(Frame::BulkString(Bytes::from_static(b"LUA")));
+
+ // Functions array
+ let func_list: Vec = lib
+ .functions
+ .values()
+ .map(|f| {
+ let mut fentry = Vec::with_capacity(4);
+ fentry.push(Frame::BulkString(Bytes::from_static(b"name")));
+ fentry.push(Frame::BulkString(f.name.clone()));
+ if let Some(desc) = &f.description {
+ fentry.push(Frame::BulkString(Bytes::from_static(b"description")));
+ fentry.push(Frame::BulkString(Bytes::copy_from_slice(desc.as_bytes())));
+ }
+ Frame::Array(fentry.into())
+ })
+ .collect();
+
+ entry.push(Frame::BulkString(Bytes::from_static(b"functions")));
+ entry.push(Frame::Array(func_list.into()));
+
+ if with_code {
+ entry.push(Frame::BulkString(Bytes::from_static(b"library_code")));
+ entry.push(Frame::BulkString(lib.source.clone()));
+ }
+
+ result.push(Frame::Array(entry.into()));
+ }
+
+ Frame::Array(result.into())
+}
+
+/// FUNCTION DELETE
+fn handle_function_delete(registry: &mut FunctionRegistry, args: &[Frame]) -> Frame {
+ if args.is_empty() {
+ return Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'function|delete' command",
+ ));
+ }
+
+ let lib_name = match &args[0] {
+ Frame::BulkString(b) => b,
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ };
+
+ if registry.delete(lib_name) {
+ Frame::SimpleString(Bytes::from_static(b"OK"))
+ } else {
+ Frame::Error(Bytes::from(format!(
+ "ERR Library '{}' not found",
+ String::from_utf8_lossy(lib_name)
+ )))
+ }
+}
+
+/// Handle FCALL: look up function by name, parse numkeys, dispatch.
+pub fn handle_fcall(
+ registry: &FunctionRegistry,
+ args: &[Frame],
+ db: &mut Database,
+ shard_id: usize,
+ num_shards: usize,
+ selected_db: usize,
+ db_count: usize,
+) -> Frame {
+ handle_fcall_inner(
+ registry,
+ args,
+ db,
+ shard_id,
+ num_shards,
+ selected_db,
+ db_count,
+ false,
+ )
+}
+
+/// Handle FCALL_RO: same as FCALL but sets read-only mode.
+pub fn handle_fcall_ro(
+ registry: &FunctionRegistry,
+ args: &[Frame],
+ db: &mut Database,
+ shard_id: usize,
+ num_shards: usize,
+ selected_db: usize,
+ db_count: usize,
+) -> Frame {
+ handle_fcall_inner(
+ registry,
+ args,
+ db,
+ shard_id,
+ num_shards,
+ selected_db,
+ db_count,
+ true,
+ )
+}
+
+/// Inner FCALL implementation shared by FCALL and FCALL_RO.
+fn handle_fcall_inner(
+ registry: &FunctionRegistry,
+ args: &[Frame],
+ db: &mut Database,
+ shard_id: usize,
+ num_shards: usize,
+ selected_db: usize,
+ db_count: usize,
+ read_only: bool,
+) -> Frame {
+ // FCALL funcname numkeys [key ...] [arg ...]
+ if args.len() < 2 {
+ return Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'fcall' command",
+ ));
+ }
+
+ let func_name = match &args[0] {
+ Frame::BulkString(b) => b,
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR invalid function name"));
+ }
+ };
+
+ let numkeys: usize = match &args[1] {
+ Frame::BulkString(b) => match std::str::from_utf8(b).ok().and_then(|s| s.parse().ok()) {
+ Some(n) => n,
+ None => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR value is not an integer or out of range",
+ ));
+ }
+ },
+ Frame::Integer(n) => {
+ if *n < 0 {
+ return Frame::Error(Bytes::from_static(
+ b"ERR value is not an integer or out of range",
+ ));
+ }
+ *n as usize
+ }
+ _ => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR value is not an integer or out of range",
+ ));
+ }
+ };
+
+ if args.len() < 2 + numkeys {
+ return Frame::Error(Bytes::from_static(
+ b"ERR Number of keys can't be greater than number of args",
+ ));
+ }
+
+ let mut keys: Vec = Vec::with_capacity(numkeys);
+ for f in &args[2..2 + numkeys] {
+ match f {
+ Frame::BulkString(b) => keys.push(b.clone()),
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR Invalid argument type for key"));
+ }
+ }
+ }
+
+ // Validate cross-shard keys
+ if num_shards > 1 {
+ if let Some(err) = crate::scripting::validate_keys_same_shard(&keys, shard_id, num_shards) {
+ return err;
+ }
+ }
+
+ let mut argv: Vec = Vec::with_capacity(args.len().saturating_sub(2 + numkeys));
+ for f in &args[2 + numkeys..] {
+ match f {
+ Frame::BulkString(b) => argv.push(b.clone()),
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR Invalid argument type for arg"));
+ }
+ }
+ }
+
+ registry.call_function(func_name, keys, argv, db, selected_db, db_count, read_only)
+}
diff --git a/src/command/hash/hash_read.rs b/src/command/hash/hash_read.rs
index 7c44d21c..da4e9c20 100644
--- a/src/command/hash/hash_read.rs
+++ b/src/command/hash/hash_read.rs
@@ -549,3 +549,226 @@ pub fn hscan_readonly(db: &Database, args: &[Frame], now_ms: u64) -> Frame {
Frame::Array(results.into()),
])
}
+
+// ---------------------------------------------------------------------------
+// HRANDFIELD key [count [WITHVALUES]]
+// ---------------------------------------------------------------------------
+
+/// HRANDFIELD key [count [WITHVALUES]]
+pub fn hrandfield(db: &mut Database, args: &[Frame]) -> Frame {
+ use rand::seq::IndexedRandom;
+ if args.is_empty() || args.len() > 3 {
+ return err_wrong_args("HRANDFIELD");
+ }
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k.as_ref(),
+ None => return err_wrong_args("HRANDFIELD"),
+ };
+ let map = match db.get_hash(key) {
+ Ok(Some(m)) => m,
+ Ok(None) => {
+ return if args.len() == 1 {
+ Frame::Null
+ } else {
+ Frame::Array(framevec![])
+ };
+ }
+ Err(e) => return e,
+ };
+ if map.is_empty() {
+ return if args.len() == 1 {
+ Frame::Null
+ } else {
+ Frame::Array(framevec![])
+ };
+ }
+ let fields: Vec<(&Bytes, &Bytes)> = map.iter().collect();
+ let mut rng = rand::rng();
+ if args.len() == 1 {
+ if let Some((field, _)) = fields.choose(&mut rng) {
+ return Frame::BulkString((*field).clone());
+ }
+ return Frame::Null;
+ }
+ let count_bytes = match extract_bytes(&args[1]) {
+ Some(b) => b,
+ None => return err_wrong_args("HRANDFIELD"),
+ };
+ let count: i64 = match std::str::from_utf8(count_bytes)
+ .ok()
+ .and_then(|s| s.parse().ok())
+ {
+ Some(c) => c,
+ None => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR value is not an integer or out of range",
+ ));
+ }
+ };
+ let with_values = if args.len() == 3 {
+ let opt = match extract_bytes(&args[2]) {
+ Some(b) => b,
+ None => return err_wrong_args("HRANDFIELD"),
+ };
+ if opt.eq_ignore_ascii_case(b"WITHVALUES") {
+ true
+ } else {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ } else {
+ false
+ };
+ if count == 0 {
+ return Frame::Array(framevec![]);
+ }
+ if count > 0 {
+ let n = std::cmp::min(count as usize, fields.len());
+ let indices: Vec = (0..fields.len()).collect();
+ let chosen: Vec = indices.as_slice().sample(&mut rng, n).copied().collect();
+ if with_values {
+ let mut result = Vec::with_capacity(n * 2);
+ for &idx in &chosen {
+ result.push(Frame::BulkString(fields[idx].0.clone()));
+ result.push(Frame::BulkString(fields[idx].1.clone()));
+ }
+ Frame::Array(result.into())
+ } else {
+ let result: Vec = chosen
+ .iter()
+ .map(|&idx| Frame::BulkString(fields[idx].0.clone()))
+ .collect();
+ Frame::Array(result.into())
+ }
+ } else {
+ // Negative count: allow duplicates. Cap to fields.len() to prevent OOM on i64::MIN.
+ let n = std::cmp::min(count.unsigned_abs() as usize, fields.len() * 10);
+ if with_values {
+ let mut result = Vec::with_capacity(n * 2);
+ for _ in 0..n {
+ if let Some((field, value)) = fields.choose(&mut rng) {
+ result.push(Frame::BulkString((*field).clone()));
+ result.push(Frame::BulkString((*value).clone()));
+ }
+ }
+ Frame::Array(result.into())
+ } else {
+ let mut result = Vec::with_capacity(n);
+ for _ in 0..n {
+ if let Some((field, _)) = fields.choose(&mut rng) {
+ result.push(Frame::BulkString((*field).clone()));
+ }
+ }
+ Frame::Array(result.into())
+ }
+ }
+}
+
+/// HRANDFIELD readonly path
+pub fn hrandfield_readonly(db: &Database, args: &[Frame], now_ms: u64) -> Frame {
+ use rand::seq::IndexedRandom;
+ if args.is_empty() || args.len() > 3 {
+ return err_wrong_args("HRANDFIELD");
+ }
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k.as_ref(),
+ None => return err_wrong_args("HRANDFIELD"),
+ };
+ let href = match db.get_hash_ref_if_alive(key, now_ms) {
+ Ok(Some(h)) => h,
+ Ok(None) => {
+ return if args.len() == 1 {
+ Frame::Null
+ } else {
+ Frame::Array(framevec![])
+ };
+ }
+ Err(e) => return e,
+ };
+ let entries = href.entries();
+ if entries.is_empty() {
+ return if args.len() == 1 {
+ Frame::Null
+ } else {
+ Frame::Array(framevec![])
+ };
+ }
+ let mut rng = rand::rng();
+ if args.len() == 1 {
+ return if let Some((field, _)) = entries.choose(&mut rng) {
+ Frame::BulkString(field.clone())
+ } else {
+ Frame::Null
+ };
+ }
+ let count_bytes = match extract_bytes(&args[1]) {
+ Some(b) => b,
+ None => return err_wrong_args("HRANDFIELD"),
+ };
+ let count: i64 = match std::str::from_utf8(count_bytes)
+ .ok()
+ .and_then(|s| s.parse().ok())
+ {
+ Some(c) => c,
+ None => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR value is not an integer or out of range",
+ ));
+ }
+ };
+ let with_values = if args.len() == 3 {
+ let opt = match extract_bytes(&args[2]) {
+ Some(b) => b,
+ None => return err_wrong_args("HRANDFIELD"),
+ };
+ if opt.eq_ignore_ascii_case(b"WITHVALUES") {
+ true
+ } else {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ } else {
+ false
+ };
+ if count == 0 {
+ return Frame::Array(framevec![]);
+ }
+ if count > 0 {
+ let n = std::cmp::min(count as usize, entries.len());
+ let indices: Vec = (0..entries.len()).collect();
+ let chosen: Vec = indices.as_slice().sample(&mut rng, n).copied().collect();
+ if with_values {
+ let mut result = Vec::with_capacity(n * 2);
+ for &idx in &chosen {
+ result.push(Frame::BulkString(entries[idx].0.clone()));
+ result.push(Frame::BulkString(entries[idx].1.clone()));
+ }
+ Frame::Array(result.into())
+ } else {
+ let result: Vec = chosen
+ .iter()
+ .map(|&idx| Frame::BulkString(entries[idx].0.clone()))
+ .collect();
+ Frame::Array(result.into())
+ }
+ } else {
+ // Negative count: allow duplicates. Cap to prevent OOM on extreme values.
+ let n = std::cmp::min(count.unsigned_abs() as usize, entries.len() * 10);
+ if with_values {
+ let mut result = Vec::with_capacity(n * 2);
+ for _ in 0..n {
+ if let Some((field, value)) = entries.choose(&mut rng) {
+ result.push(Frame::BulkString(field.clone()));
+ result.push(Frame::BulkString(value.clone()));
+ }
+ }
+ Frame::Array(result.into())
+ } else {
+ let mut result = Vec::with_capacity(n);
+ for _ in 0..n {
+ if let Some((field, _)) = entries.choose(&mut rng) {
+ result.push(Frame::BulkString(field.clone()));
+ }
+ }
+ Frame::Array(result.into())
+ }
+ }
+}
diff --git a/src/command/hll.rs b/src/command/hll.rs
new file mode 100644
index 00000000..cd280532
--- /dev/null
+++ b/src/command/hll.rs
@@ -0,0 +1,235 @@
+//! PFADD, PFCOUNT, PFMERGE command handlers.
+//!
+//! HLL values are stored as `RedisValue::String(Bytes)` — the raw HYLL wire
+//! bytes. Redis `TYPE` reports "string" for HLL keys.
+
+use bytes::Bytes;
+
+use crate::protocol::Frame;
+use crate::storage::Database;
+use crate::storage::entry::Entry;
+use crate::storage::hll::Hll;
+
+use super::helpers::{err_wrong_args, extract_bytes, ok};
+
+/// Redis-exact WRONGTYPE error for non-HLL string values.
+const WRONGTYPE_HLL: &[u8] = b"WRONGTYPE Key is not a valid HyperLogLog string value.";
+
+/// Load an existing HLL from the database (mutable access).
+fn load_hll(db: &mut Database, key: &[u8]) -> Result, Frame> {
+ match db.get(key) {
+ Some(entry) => {
+ let raw = match entry.value.as_bytes() {
+ Some(b) => b,
+ None => return Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL))),
+ };
+ if !Hll::is_hll(raw) {
+ return Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL)));
+ }
+ let owned = match entry.value.as_bytes_owned() {
+ Some(b) => b,
+ None => return Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL))),
+ };
+ match Hll::from_bytes(owned) {
+ Ok(hll) => Ok(Some(hll)),
+ Err(_) => Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL))),
+ }
+ }
+ None => Ok(None),
+ }
+}
+
+/// Load an existing HLL from the database (read-only access).
+fn load_hll_readonly(db: &Database, key: &[u8], now_ms: u64) -> Result, Frame> {
+ match db.get_if_alive(key, now_ms) {
+ Some(entry) => {
+ let raw = match entry.value.as_bytes() {
+ Some(b) => b,
+ None => return Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL))),
+ };
+ if !Hll::is_hll(raw) {
+ return Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL)));
+ }
+ let owned = match entry.value.as_bytes_owned() {
+ Some(b) => b,
+ None => return Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL))),
+ };
+ match Hll::from_bytes(owned) {
+ Ok(hll) => Ok(Some(hll)),
+ Err(_) => Err(Frame::Error(Bytes::from_static(WRONGTYPE_HLL))),
+ }
+ }
+ None => Ok(None),
+ }
+}
+
+/// Store HLL back into the database as RedisValue::String.
+fn store_hll(db: &mut Database, key: Bytes, hll: Hll) {
+ let mut entry = Entry::new_string(hll.into_bytes());
+ entry.set_last_access(db.now());
+ entry.set_access_counter(5);
+ db.set(key, entry);
+}
+
+/// PFADD key [element [element ...]]
+///
+/// Adds elements to the HLL. Returns 1 if any register changed (or key
+/// was created), 0 otherwise.
+pub fn pfadd(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.is_empty() {
+ return err_wrong_args("PFADD");
+ }
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("PFADD"),
+ };
+ let key_owned = key.clone();
+
+ let existing = match load_hll(db, key) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+
+ let mut created = false;
+ let mut hll = match existing {
+ Some(h) => h,
+ None => {
+ created = true;
+ Hll::new_sparse()
+ }
+ };
+
+ let mut changed = created;
+ for arg in &args[1..] {
+ if let Some(elem) = extract_bytes(arg) {
+ if hll.add(elem) {
+ changed = true;
+ }
+ }
+ }
+
+ if changed {
+ store_hll(db, key_owned, hll);
+ Frame::Integer(1)
+ } else {
+ Frame::Integer(0)
+ }
+}
+
+/// PFCOUNT key [key ...] — read-only dispatch path.
+///
+/// Single key: return cardinality estimate.
+/// Multiple keys: merge into temp HLL and return merged cardinality.
+/// Does NOT mutate any source key.
+pub fn pfcount_readonly(db: &Database, args: &[Frame], now_ms: u64) -> Frame {
+ if args.is_empty() {
+ return err_wrong_args("PFCOUNT");
+ }
+
+ if args.len() == 1 {
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("PFCOUNT"),
+ };
+ match load_hll_readonly(db, key, now_ms) {
+ Ok(Some(hll)) => {
+ let count = hll.count();
+ Frame::Integer(count as i64)
+ }
+ Ok(None) => Frame::Integer(0),
+ Err(e) => e,
+ }
+ } else {
+ let mut merged = Hll::new_sparse();
+ for arg in args {
+ let key = match extract_bytes(arg) {
+ Some(k) => k,
+ None => return err_wrong_args("PFCOUNT"),
+ };
+ match load_hll_readonly(db, key, now_ms) {
+ Ok(Some(hll)) => {
+ merged.merge_from(&hll);
+ }
+ Ok(None) => {}
+ Err(e) => return e,
+ }
+ }
+ let count = merged.count();
+ Frame::Integer(count as i64)
+ }
+}
+
+/// PFCOUNT key [key ...] — write dispatch path (for mutable access).
+pub fn pfcount(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.is_empty() {
+ return err_wrong_args("PFCOUNT");
+ }
+
+ if args.len() == 1 {
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("PFCOUNT"),
+ };
+ match load_hll(db, key) {
+ Ok(Some(hll)) => {
+ let count = hll.count();
+ Frame::Integer(count as i64)
+ }
+ Ok(None) => Frame::Integer(0),
+ Err(e) => e,
+ }
+ } else {
+ let mut merged = Hll::new_sparse();
+ for arg in args {
+ let key = match extract_bytes(arg) {
+ Some(k) => k,
+ None => return err_wrong_args("PFCOUNT"),
+ };
+ match load_hll(db, key) {
+ Ok(Some(hll)) => {
+ merged.merge_from(&hll);
+ }
+ Ok(None) => {}
+ Err(e) => return e,
+ }
+ }
+ let count = merged.count();
+ Frame::Integer(count as i64)
+ }
+}
+
+/// PFMERGE destkey sourcekey [sourcekey ...]
+pub fn pfmerge(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() < 2 {
+ return err_wrong_args("PFMERGE");
+ }
+
+ let dest_key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("PFMERGE"),
+ };
+ let dest_key_owned = dest_key.clone();
+
+ let mut dest_hll = match load_hll(db, dest_key) {
+ Ok(Some(h)) => h,
+ Ok(None) => Hll::new_sparse(),
+ Err(e) => return e,
+ };
+
+ for arg in &args[1..] {
+ let src_key = match extract_bytes(arg) {
+ Some(k) => k,
+ None => return err_wrong_args("PFMERGE"),
+ };
+ match load_hll(db, src_key) {
+ Ok(Some(hll)) => {
+ dest_hll.merge_from(&hll);
+ }
+ Ok(None) => {}
+ Err(e) => return e,
+ }
+ }
+
+ store_hll(db, dest_key_owned, dest_hll);
+ ok()
+}
diff --git a/src/command/list/list_write.rs b/src/command/list/list_write.rs
index 90f3513d..66b26365 100644
--- a/src/command/list/list_write.rs
+++ b/src/command/list/list_write.rs
@@ -607,3 +607,177 @@ pub fn lmove(db: &mut Database, args: &[Frame]) -> Frame {
Frame::BulkString(value)
}
+
+// ---------------------------------------------------------------------------
+// LPUSHX key element [element ...]
+// ---------------------------------------------------------------------------
+
+/// LPUSHX key element [element ...]
+/// Pushes elements to the front of the list ONLY if the key already exists as a list.
+pub fn lpushx(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() < 2 {
+ return err_wrong_args("LPUSHX");
+ }
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("LPUSHX"),
+ };
+
+ match db.get_list(key) {
+ Ok(None) => return Frame::Integer(0),
+ Err(e) => return e,
+ Ok(Some(_)) => {}
+ }
+
+ let list = match db.get_or_create_list(key) {
+ Ok(l) => l,
+ Err(e) => return e,
+ };
+ for arg in &args[1..] {
+ let val = match extract_bytes(arg) {
+ Some(v) => v.clone(),
+ None => return err_wrong_args("LPUSHX"),
+ };
+ list.push_front(val);
+ }
+ Frame::Integer(list.len() as i64)
+}
+
+// ---------------------------------------------------------------------------
+// RPUSHX key element [element ...]
+// ---------------------------------------------------------------------------
+
+/// RPUSHX key element [element ...]
+/// Pushes elements to the back of the list ONLY if the key already exists as a list.
+pub fn rpushx(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() < 2 {
+ return err_wrong_args("RPUSHX");
+ }
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("RPUSHX"),
+ };
+
+ match db.get_list(key) {
+ Ok(None) => return Frame::Integer(0),
+ Err(e) => return e,
+ Ok(Some(_)) => {}
+ }
+
+ let list = match db.get_or_create_list(key) {
+ Ok(l) => l,
+ Err(e) => return e,
+ };
+ for arg in &args[1..] {
+ let val = match extract_bytes(arg) {
+ Some(v) => v.clone(),
+ None => return err_wrong_args("RPUSHX"),
+ };
+ list.push_back(val);
+ }
+ Frame::Integer(list.len() as i64)
+}
+
+// ---------------------------------------------------------------------------
+// LMPOP numkeys key [key ...] LEFT|RIGHT [COUNT count]
+// ---------------------------------------------------------------------------
+
+/// LMPOP numkeys key [key ...] LEFT|RIGHT [COUNT count]
+/// Pops elements from the first non-empty list among the specified keys.
+pub fn lmpop(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() < 3 {
+ return err_wrong_args("LMPOP");
+ }
+ let numkeys = match parse_i64(&args[0]) {
+ Some(n) if n > 0 => n as usize,
+ _ => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR numkeys can't be non-positive value",
+ ));
+ }
+ };
+ if args.len() < 1 + numkeys + 1 {
+ return err_wrong_args("LMPOP");
+ }
+
+ let dir_bytes = match extract_bytes(&args[1 + numkeys]) {
+ Some(b) => b,
+ None => return Frame::Error(Bytes::from_static(b"ERR syntax error")),
+ };
+ let left = if dir_bytes.eq_ignore_ascii_case(b"LEFT") {
+ true
+ } else if dir_bytes.eq_ignore_ascii_case(b"RIGHT") {
+ false
+ } else {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ };
+
+ let mut count: usize = 1;
+ let remaining = &args[2 + numkeys..];
+ if remaining.len() >= 2 {
+ if let Some(kw) = extract_bytes(&remaining[0]) {
+ if kw.eq_ignore_ascii_case(b"COUNT") {
+ match parse_i64(&remaining[1]) {
+ Some(c) if c > 0 => count = c as usize,
+ _ => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR COUNT value of LMPOP command is not an integer or out of range",
+ ));
+ }
+ }
+ } else {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ }
+ } else if !remaining.is_empty() {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+
+ for i in 0..numkeys {
+ let key = match extract_bytes(&args[1 + i]) {
+ Some(k) => k.clone(),
+ None => return err_wrong_args("LMPOP"),
+ };
+
+ let list_len = match db.get_list(&key) {
+ Ok(Some(l)) => l.len(),
+ Ok(None) => continue,
+ Err(e) => return e,
+ };
+ if list_len == 0 {
+ continue;
+ }
+
+ let n = count.min(list_len);
+ let list = match db.get_or_create_list(&key) {
+ Ok(l) => l,
+ Err(e) => return e,
+ };
+ let mut elems = Vec::with_capacity(n);
+ for _ in 0..n {
+ let val = if left {
+ list.pop_front()
+ } else {
+ list.pop_back()
+ };
+ match val {
+ Some(v) => elems.push(Frame::BulkString(v)),
+ None => break,
+ }
+ }
+
+ if list.is_empty() {
+ db.remove(&key);
+ }
+
+ if elems.is_empty() {
+ continue;
+ }
+ return Frame::Array(framevec![
+ Frame::BulkString(key),
+ Frame::Array(elems.into()),
+ ]);
+ }
+
+ Frame::Null
+}
diff --git a/src/command/list/mod.rs b/src/command/list/mod.rs
index c9f62b4d..dacbe6f6 100644
--- a/src/command/list/mod.rs
+++ b/src/command/list/mod.rs
@@ -43,13 +43,16 @@ pub use list_read::lrange_readonly;
// ---------------------------------------------------------------------------
pub use list_write::linsert;
pub use list_write::lmove;
+pub use list_write::lmpop;
pub use list_write::lpop;
pub use list_write::lpush;
+pub use list_write::lpushx;
pub use list_write::lrem;
pub use list_write::lset;
pub use list_write::ltrim;
pub use list_write::rpop;
pub use list_write::rpush;
+pub use list_write::rpushx;
// ===========================================================================
// Tests
diff --git a/src/command/metadata.rs b/src/command/metadata.rs
index 34faaabd..787b06bb 100644
--- a/src/command/metadata.rs
+++ b/src/command/metadata.rs
@@ -172,6 +172,7 @@ pub static COMMAND_META: phf::Map<&'static str, CommandMeta> = phf_map! {
"HEXISTS" => CommandMeta { name: "HEXISTS", arity: 3, flags: RF, first_key: 1, last_key: 1, step: 1, acl_categories: HSH },
"HINCRBY" => CommandMeta { name: "HINCRBY", arity: 4, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: HSH },
"HINCRBYFLOAT" => CommandMeta { name: "HINCRBYFLOAT", arity: 4, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: HSH },
+ "HRANDFIELD" => CommandMeta { name: "HRANDFIELD", arity: -2, flags: R, first_key: 1, last_key: 1, step: 1, acl_categories: HSH },
// ---- List commands ----
"LPUSH" => CommandMeta { name: "LPUSH", arity: -3, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: LST },
@@ -187,6 +188,21 @@ pub static COMMAND_META: phf::Map<&'static str, CommandMeta> = phf_map! {
"LINSERT" => CommandMeta { name: "LINSERT", arity: 5, flags: W, first_key: 1, last_key: 1, step: 1, acl_categories: LST },
"LTRIM" => CommandMeta { name: "LTRIM", arity: 4, flags: W, first_key: 1, last_key: 1, step: 1, acl_categories: LST },
"LMOVE" => CommandMeta { name: "LMOVE", arity: 5, flags: W, first_key: 1, last_key: 2, step: 1, acl_categories: LST },
+ "LPUSHX" => CommandMeta { name: "LPUSHX", arity: -3, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: LST },
+ "RPUSHX" => CommandMeta { name: "RPUSHX", arity: -3, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: LST },
+ "LMPOP" => CommandMeta { name: "LMPOP", arity: -4, flags: W, first_key: 0, last_key: 0, step: 0, acl_categories: LST },
+
+ // ---- Blocking list commands ----
+ "BLPOP" => CommandMeta { name: "BLPOP", arity: -3, flags: W, first_key: 1, last_key: -2, step: 1, acl_categories: AclCategories(AclCategories::LIST.0 | AclCategories::SLOW.0) },
+ "BRPOP" => CommandMeta { name: "BRPOP", arity: -3, flags: W, first_key: 1, last_key: -2, step: 1, acl_categories: AclCategories(AclCategories::LIST.0 | AclCategories::SLOW.0) },
+ "BLMOVE" => CommandMeta { name: "BLMOVE", arity: 6, flags: W, first_key: 1, last_key: 2, step: 1, acl_categories: AclCategories(AclCategories::LIST.0 | AclCategories::SLOW.0) },
+ "BLMPOP" => CommandMeta { name: "BLMPOP", arity: -5, flags: W, first_key: 0, last_key: 0, step: 0, acl_categories: AclCategories(AclCategories::LIST.0 | AclCategories::SLOW.0) },
+ "BRPOPLPUSH" => CommandMeta { name: "BRPOPLPUSH", arity: 4, flags: W, first_key: 1, last_key: 2, step: 1, acl_categories: AclCategories(AclCategories::LIST.0 | AclCategories::SLOW.0) },
+
+ // ---- Blocking sorted-set commands ----
+ "BZPOPMIN" => CommandMeta { name: "BZPOPMIN", arity: -3, flags: W, first_key: 1, last_key: -2, step: 1, acl_categories: AclCategories(AclCategories::SORTEDSET.0 | AclCategories::SLOW.0) },
+ "BZPOPMAX" => CommandMeta { name: "BZPOPMAX", arity: -3, flags: W, first_key: 1, last_key: -2, step: 1, acl_categories: AclCategories(AclCategories::SORTEDSET.0 | AclCategories::SLOW.0) },
+ "BZMPOP" => CommandMeta { name: "BZMPOP", arity: -5, flags: W, first_key: 0, last_key: 0, step: 0, acl_categories: AclCategories(AclCategories::SORTEDSET.0 | AclCategories::SLOW.0) },
// ---- Set commands ----
"SADD" => CommandMeta { name: "SADD", arity: -3, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: SET_CAT },
@@ -204,6 +220,8 @@ pub static COMMAND_META: phf::Map<&'static str, CommandMeta> = phf_map! {
"SDIFFSTORE" => CommandMeta { name: "SDIFFSTORE", arity: -3, flags: W, first_key: 1, last_key: -1, step: 1, acl_categories: SET_CAT },
"SINTERSTORE" => CommandMeta { name: "SINTERSTORE", arity: -3, flags: W, first_key: 1, last_key: -1, step: 1, acl_categories: SET_CAT },
"SUNIONSTORE" => CommandMeta { name: "SUNIONSTORE", arity: -3, flags: W, first_key: 1, last_key: -1, step: 1, acl_categories: SET_CAT },
+ "SMOVE" => CommandMeta { name: "SMOVE", arity: 4, flags: WF, first_key: 1, last_key: 2, step: 1, acl_categories: SET_CAT },
+ "SINTERCARD" => CommandMeta { name: "SINTERCARD", arity: -3, flags: R, first_key: 0, last_key: 0, step: 0, acl_categories: SET_CAT },
// ---- Sorted-set commands ----
"ZADD" => CommandMeta { name: "ZADD", arity: -4, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: ZST },
@@ -224,6 +242,14 @@ pub static COMMAND_META: phf::Map<&'static str, CommandMeta> = phf_map! {
"ZINTERSTORE" => CommandMeta { name: "ZINTERSTORE", arity: -4, flags: W, first_key: 1, last_key: 1, step: 1, acl_categories: ZST },
"ZRANGEBYSCORE" => CommandMeta { name: "ZRANGEBYSCORE", arity: -4, flags: R, first_key: 1, last_key: 1, step: 1, acl_categories: ZST },
"ZREVRANGEBYSCORE" => CommandMeta { name: "ZREVRANGEBYSCORE", arity: -4, flags: R, first_key: 1, last_key: 1, step: 1, acl_categories: ZST },
+ "ZRANGESTORE" => CommandMeta { name: "ZRANGESTORE", arity: -5, flags: W, first_key: 1, last_key: 2, step: 1, acl_categories: ZST },
+ "ZDIFF" => CommandMeta { name: "ZDIFF", arity: -3, flags: R, first_key: 0, last_key: 0, step: 0, acl_categories: ZST },
+ "ZUNION" => CommandMeta { name: "ZUNION", arity: -3, flags: R, first_key: 0, last_key: 0, step: 0, acl_categories: ZST },
+ "ZINTER" => CommandMeta { name: "ZINTER", arity: -3, flags: R, first_key: 0, last_key: 0, step: 0, acl_categories: ZST },
+ "ZINTERCARD" => CommandMeta { name: "ZINTERCARD", arity: -3, flags: R, first_key: 0, last_key: 0, step: 0, acl_categories: ZST },
+ "ZMSCORE" => CommandMeta { name: "ZMSCORE", arity: -3, flags: RF, first_key: 1, last_key: 1, step: 1, acl_categories: ZST },
+ "ZRANDMEMBER" => CommandMeta { name: "ZRANDMEMBER", arity: -2, flags: R, first_key: 1, last_key: 1, step: 1, acl_categories: ZST },
+ "ZMPOP" => CommandMeta { name: "ZMPOP", arity: -4, flags: W, first_key: 0, last_key: 0, step: 0, acl_categories: ZST },
// ---- Stream commands ----
"XADD" => CommandMeta { name: "XADD", arity: -5, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: STM },
@@ -274,6 +300,11 @@ pub static COMMAND_META: phf::Map<&'static str, CommandMeta> = phf_map! {
"BITFIELD" => CommandMeta { name: "BITFIELD", arity: -2, flags: W, first_key: 1, last_key: 1, step: 1, acl_categories: STR },
"BITPOS" => CommandMeta { name: "BITPOS", arity: -3, flags: R, first_key: 1, last_key: 1, step: 1, acl_categories: STR },
+ // ---- HyperLogLog commands ----
+ "PFADD" => CommandMeta { name: "PFADD", arity: -2, flags: WF, first_key: 1, last_key: 1, step: 1, acl_categories: STR },
+ "PFCOUNT" => CommandMeta { name: "PFCOUNT", arity: -2, flags: R, first_key: 1, last_key: -1, step: 1, acl_categories: STR },
+ "PFMERGE" => CommandMeta { name: "PFMERGE", arity: -2, flags: W, first_key: 1, last_key: -1, step: 1, acl_categories: STR },
+
// ---- Geo commands ----
"GEOADD" => CommandMeta { name: "GEOADD", arity: -5, flags: W, first_key: 1, last_key: 1, step: 1, acl_categories: GEN },
"GEODIST" => CommandMeta { name: "GEODIST", arity: -4, flags: R, first_key: 1, last_key: 1, step: 1, acl_categories: GEN },
@@ -329,6 +360,9 @@ pub static COMMAND_META: phf::Map<&'static str, CommandMeta> = phf_map! {
"EVAL" => CommandMeta { name: "EVAL", arity: -3, flags: CommandFlags(CommandFlags::NOSCRIPT.0 | CommandFlags::MAY_REPLICATE.0), first_key: 0, last_key: 0, step: 0, acl_categories: SCR },
"EVALSHA" => CommandMeta { name: "EVALSHA", arity: -3, flags: CommandFlags(CommandFlags::NOSCRIPT.0 | CommandFlags::MAY_REPLICATE.0), first_key: 0, last_key: 0, step: 0, acl_categories: SCR },
"SCRIPT" => CommandMeta { name: "SCRIPT", arity: -2, flags: R, first_key: 0, last_key: 0, step: 0, acl_categories: SCR },
+ "FUNCTION" => CommandMeta { name: "FUNCTION", arity: -2, flags: W, first_key: 0, last_key: 0, step: 0, acl_categories: SCR },
+ "FCALL" => CommandMeta { name: "FCALL", arity: -3, flags: W, first_key: 3, last_key: 0, step: 1, acl_categories: SCR },
+ "FCALL_RO" => CommandMeta { name: "FCALL_RO", arity: -3, flags: R, first_key: 3, last_key: 0, step: 1, acl_categories: SCR },
// ---- Transaction commands ----
"MULTI" => CommandMeta { name: "MULTI", arity: 1, flags: RF, first_key: 0, last_key: 0, step: 0, acl_categories: TXN },
@@ -667,9 +701,13 @@ mod tests {
b"LREM",
b"LTRIM",
b"LMOVE",
+ b"LPUSHX",
+ b"RPUSHX",
+ b"LMPOP",
b"SADD",
b"SREM",
b"SPOP",
+ b"SMOVE",
b"SINTERSTORE",
b"SUNIONSTORE",
b"SDIFFSTORE",
@@ -680,6 +718,8 @@ mod tests {
b"ZPOPMAX",
b"ZUNIONSTORE",
b"ZINTERSTORE",
+ b"ZRANGESTORE",
+ b"ZMPOP",
b"SELECT",
];
for cmd in aof_write_cmds {
@@ -728,6 +768,8 @@ mod tests {
b"ZLEXCOUNT",
b"ZRANGEBYSCORE",
b"ZREVRANGEBYSCORE",
+ b"SINTERCARD",
+ b"HRANDFIELD",
b"XLEN",
b"XREAD",
b"XINFO",
@@ -824,6 +866,8 @@ mod tests {
b"SUNIONSTORE",
b"ZUNIONSTORE",
b"ZINTERSTORE",
+ b"ZRANGESTORE",
+ b"ZMPOP",
b"HINCRBYFLOAT",
b"LSET",
b"LREM",
diff --git a/src/command/mod.rs b/src/command/mod.rs
index 029e6fa7..109ac3ba 100644
--- a/src/command/mod.rs
+++ b/src/command/mod.rs
@@ -2,8 +2,10 @@ pub mod acl;
pub mod client;
pub mod config;
pub mod connection;
+pub mod functions;
pub mod hash;
pub mod helpers;
+pub mod hll;
pub mod key;
pub mod list;
pub mod metadata;
@@ -263,6 +265,15 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"LMOVE") {
return resp(list::lmove(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"LMPOP") {
+ return resp(list::lmpop(db, args));
+ }
+ }
+ (5, b'p') => {
+ // PFADD
+ if cmd.eq_ignore_ascii_case(b"PFADD") {
+ return resp(hll::pfadd(db, args));
+ }
}
(5, b'r') => {
// RPUSH
@@ -295,6 +306,12 @@ fn dispatch_inner(
return resp(set::sdiff(db, args));
}
}
+ b'm' => {
+ // SMOVE
+ if cmd.eq_ignore_ascii_case(b"SMOVE") {
+ return resp(set::smove(db, args));
+ }
+ }
b's' => {
// SSCAN
if cmd.eq_ignore_ascii_case(b"SSCAN") {
@@ -327,6 +344,12 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"ZSCAN") {
return resp(sorted_set::zscan(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"ZDIFF") {
+ return resp(sorted_set::zdiff(db, args));
+ }
+ if cmd.eq_ignore_ascii_case(b"ZMPOP") {
+ return resp(sorted_set::zmpop(db, args));
+ }
}
// 6-letter commands
(6, b'a') => {
@@ -382,6 +405,9 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"LINDEX") {
return resp(list::lindex(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"LPUSHX") {
+ return resp(list::lpushx(db, args));
+ }
}
(6, b'o') => {
// OBJECT
@@ -403,6 +429,9 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"RENAME") {
return resp(key::rename(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"RPUSHX") {
+ return resp(list::rpushx(db, args));
+ }
}
(6, b's') => {
// SELECT STRLEN SUBSTR SINTER SUNION
@@ -463,6 +492,12 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"ZCOUNT") {
return resp(sorted_set::zcount(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"ZUNION") {
+ return resp(sorted_set::zunion(db, args));
+ }
+ if cmd.eq_ignore_ascii_case(b"ZINTER") {
+ return resp(sorted_set::zinter(db, args));
+ }
}
// 7-letter commands
(7, b'c') => {
@@ -500,6 +535,12 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"PERSIST") {
return resp(key::persist(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"PFCOUNT") {
+ return resp(hll::pfcount(db, args));
+ }
+ if cmd.eq_ignore_ascii_case(b"PFMERGE") {
+ return resp(hll::pfmerge(db, args));
+ }
}
(7, b's') => {
// SLOWLOG
@@ -511,7 +552,7 @@ fn dispatch_inner(
}
}
(7, b'z') => {
- // ZINCRBY ZPOPMIN ZPOPMAX
+ // ZINCRBY ZPOPMIN ZPOPMAX ZMSCORE
if cmd.eq_ignore_ascii_case(b"ZINCRBY") {
return resp(sorted_set::zincrby(db, args));
}
@@ -521,6 +562,9 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"ZPOPMAX") {
return resp(sorted_set::zpopmax(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"ZMSCORE") {
+ return resp(sorted_set::zmscore(db, args));
+ }
}
// 8-letter commands
(8, b'g') => {
@@ -579,14 +623,23 @@ fn dispatch_inner(
}
}
// 10-letter commands
+ (10, b'h') => {
+ // HRANDFIELD
+ if cmd.eq_ignore_ascii_case(b"HRANDFIELD") {
+ return resp(hash::hrandfield(db, args));
+ }
+ }
(10, b's') => {
- // SMISMEMBER SDIFFSTORE
+ // SMISMEMBER SDIFFSTORE SINTERCARD
if cmd.eq_ignore_ascii_case(b"SMISMEMBER") {
return resp(set::smismember(db, args));
}
if cmd.eq_ignore_ascii_case(b"SDIFFSTORE") {
return resp(set::sdiffstore(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"SINTERCARD") {
+ return resp(set::sintercard(db, args));
+ }
}
(10, b'x') => {
// XREADGROUP XAUTOCLAIM
@@ -597,6 +650,12 @@ fn dispatch_inner(
return resp(stream::xautoclaim(db, args));
}
}
+ (10, b'z') => {
+ // ZINTERCARD
+ if cmd.eq_ignore_ascii_case(b"ZINTERCARD") {
+ return resp(sorted_set::zintercard(db, args));
+ }
+ }
// 11-letter commands
(11, b'i') => {
// INCRBYFLOAT
@@ -624,6 +683,12 @@ fn dispatch_inner(
if cmd.eq_ignore_ascii_case(b"ZINTERSTORE") {
return resp(sorted_set::zinterstore(db, args));
}
+ if cmd.eq_ignore_ascii_case(b"ZRANGESTORE") {
+ return resp(sorted_set::zrangestore(db, args));
+ }
+ if cmd.eq_ignore_ascii_case(b"ZRANDMEMBER") {
+ return resp(sorted_set::zrandmember(db, args));
+ }
}
// 12-letter commands
(12, b'h') => {
@@ -704,12 +769,14 @@ pub fn is_dispatch_read_supported(cmd: &[u8]) -> bool {
| (6, b'z') // ZSCORE, ZRANGE, ZCOUNT
| (7, b'c') // COMMAND
| (7, b'h') // HGETALL, HEXISTS
+ | (7, b'p') // PFCOUNT
| (8, b'g') // GETRANGE
| (8, b's') // SMEMBERS
| (8, b'z') // ZREVRANK
| (9, b's') // SISMEMBER
| (9, b'z') // ZREVRANGE, ZLEXCOUNT
- | (10, b's') // SMISMEMBER
+ | (10, b'h') // HRANDFIELD
+ | (10, b's') // SMISMEMBER, SINTERCARD
| (11, b's') // SRANDMEMBER
| (13, b'z') // ZRANGEBYSCORE
| (16, b'z') // ZREVRANGEBYSCORE
@@ -912,6 +979,12 @@ fn dispatch_read_inner(db: &Database, cmd: &[u8], args: &[Frame], now_ms: u64) -
return resp(hash::hexists_readonly(db, args, now_ms));
}
}
+ (7, b'p') => {
+ // PFCOUNT (read-only path)
+ if cmd.eq_ignore_ascii_case(b"PFCOUNT") {
+ return resp(hll::pfcount_readonly(db, args, now_ms));
+ }
+ }
(8, b'g') => {
// GETRANGE
if cmd.eq_ignore_ascii_case(b"GETRANGE") {
@@ -945,11 +1018,20 @@ fn dispatch_read_inner(db: &Database, cmd: &[u8], args: &[Frame], now_ms: u64) -
return resp(sorted_set::zlexcount_readonly(db, args, now_ms));
}
}
+ (10, b'h') => {
+ // HRANDFIELD
+ if cmd.eq_ignore_ascii_case(b"HRANDFIELD") {
+ return resp(hash::hrandfield_readonly(db, args, now_ms));
+ }
+ }
(10, b's') => {
- // SMISMEMBER
+ // SMISMEMBER SINTERCARD
if cmd.eq_ignore_ascii_case(b"SMISMEMBER") {
return resp(set::smismember_readonly(db, args, now_ms));
}
+ if cmd.eq_ignore_ascii_case(b"SINTERCARD") {
+ return resp(set::sintercard_readonly(db, args, now_ms));
+ }
}
(11, b's') => {
// SRANDMEMBER
diff --git a/src/command/set/mod.rs b/src/command/set/mod.rs
index 1e9fc30b..21531ead 100644
--- a/src/command/set/mod.rs
+++ b/src/command/set/mod.rs
@@ -108,9 +108,12 @@ pub use set_read::sunion_readonly;
// ---------------------------------------------------------------------------
// Re-exports: write operations
// ---------------------------------------------------------------------------
+pub use set_read::sintercard;
+pub use set_read::sintercard_readonly;
pub use set_write::sadd;
pub use set_write::sdiffstore;
pub use set_write::sinterstore;
+pub use set_write::smove;
pub use set_write::spop;
pub use set_write::srem;
pub use set_write::sunionstore;
diff --git a/src/command/set/set_read.rs b/src/command/set/set_read.rs
index d3f88301..ab70d4f0 100644
--- a/src/command/set/set_read.rs
+++ b/src/command/set/set_read.rs
@@ -748,3 +748,160 @@ pub fn sscan_readonly(db: &Database, args: &[Frame], now_ms: u64) -> Frame {
Frame::Array(results.into()),
])
}
+
+// ---------------------------------------------------------------------------
+// SINTERCARD numkeys key [key ...] [LIMIT limit]
+// ---------------------------------------------------------------------------
+
+/// SINTERCARD numkeys key [key ...] [LIMIT limit]
+pub fn sintercard(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() < 2 {
+ return err_wrong_args("SINTERCARD");
+ }
+ let numkeys = match parse_int(&args[0]) {
+ Some(n) if n > 0 => n as usize,
+ _ => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR numkeys can't be non-positive value",
+ ));
+ }
+ };
+ if args.len() < 1 + numkeys {
+ return err_wrong_args("SINTERCARD");
+ }
+
+ let mut limit: usize = 0;
+ let remaining = &args[1 + numkeys..];
+ if remaining.len() >= 2 {
+ let kw = match extract_bytes(&remaining[0]) {
+ Some(b) => b,
+ None => return Frame::Error(Bytes::from_static(b"ERR syntax error")),
+ };
+ if kw.eq_ignore_ascii_case(b"LIMIT") {
+ match parse_int(&remaining[1]) {
+ Some(l) if l >= 0 => limit = l as usize,
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR LIMIT can't be negative"));
+ }
+ }
+ } else {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ } else if !remaining.is_empty() {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+
+ let key_frames = &args[1..1 + numkeys];
+ let keys: Vec<&Bytes> = key_frames.iter().filter_map(extract_bytes).collect();
+ if keys.len() != numkeys {
+ return err_wrong_args("SINTERCARD");
+ }
+
+ let sets = match collect_sets(db, &keys) {
+ Ok(s) => s,
+ Err(e) => return e,
+ };
+
+ let mut concrete: Vec> = Vec::new();
+ for s in sets {
+ match s {
+ Some(set) => concrete.push(set),
+ None => return Frame::Integer(0),
+ }
+ }
+
+ if concrete.is_empty() {
+ return Frame::Integer(0);
+ }
+
+ concrete.sort_by_key(|s| s.len());
+ let smallest = &concrete[0];
+ let rest = &concrete[1..];
+
+ let mut count: usize = 0;
+ for member in smallest {
+ if rest.iter().all(|s| s.contains(member)) {
+ count += 1;
+ if limit > 0 && count >= limit {
+ break;
+ }
+ }
+ }
+
+ Frame::Integer(count as i64)
+}
+
+/// SINTERCARD readonly path
+pub fn sintercard_readonly(db: &Database, args: &[Frame], now_ms: u64) -> Frame {
+ if args.len() < 2 {
+ return err_wrong_args("SINTERCARD");
+ }
+ let numkeys = match parse_int(&args[0]) {
+ Some(n) if n > 0 => n as usize,
+ _ => {
+ return Frame::Error(Bytes::from_static(
+ b"ERR numkeys can't be non-positive value",
+ ));
+ }
+ };
+ if args.len() < 1 + numkeys {
+ return err_wrong_args("SINTERCARD");
+ }
+
+ let mut limit: usize = 0;
+ let remaining = &args[1 + numkeys..];
+ if remaining.len() >= 2 {
+ let kw = match extract_bytes(&remaining[0]) {
+ Some(b) => b,
+ None => return Frame::Error(Bytes::from_static(b"ERR syntax error")),
+ };
+ if kw.eq_ignore_ascii_case(b"LIMIT") {
+ match parse_int(&remaining[1]) {
+ Some(l) if l >= 0 => limit = l as usize,
+ _ => {
+ return Frame::Error(Bytes::from_static(b"ERR LIMIT can't be negative"));
+ }
+ }
+ } else {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+ } else if !remaining.is_empty() {
+ return Frame::Error(Bytes::from_static(b"ERR syntax error"));
+ }
+
+ let key_frames = &args[1..1 + numkeys];
+ let keys: Vec<&Bytes> = key_frames.iter().filter_map(extract_bytes).collect();
+ if keys.len() != numkeys {
+ return err_wrong_args("SINTERCARD");
+ }
+
+ // Use readonly path to get sets
+ let mut concrete: Vec> = Vec::new();
+ for key in &keys {
+ match db.get_set_ref_if_alive(key, now_ms) {
+ Ok(Some(sref)) => concrete.push(sref.members().into_iter().collect()),
+ Ok(None) => return Frame::Integer(0),
+ Err(e) => return e,
+ }
+ }
+
+ if concrete.is_empty() {
+ return Frame::Integer(0);
+ }
+
+ concrete.sort_by_key(|s| s.len());
+ let smallest = &concrete[0];
+ let rest = &concrete[1..];
+
+ let mut count: usize = 0;
+ for member in smallest {
+ if rest.iter().all(|s| s.contains(member)) {
+ count += 1;
+ if limit > 0 && count >= limit {
+ break;
+ }
+ }
+ }
+
+ Frame::Integer(count as i64)
+}
diff --git a/src/command/set/set_write.rs b/src/command/set/set_write.rs
index 492be3d1..0416720f 100644
--- a/src/command/set/set_write.rs
+++ b/src/command/set/set_write.rs
@@ -411,3 +411,69 @@ pub fn sdiffstore(db: &mut Database, args: &[Frame]) -> Frame {
}
Frame::Integer(count)
}
+
+// ---------------------------------------------------------------------------
+// SMOVE source destination member
+// ---------------------------------------------------------------------------
+
+/// SMOVE source destination member
+pub fn smove(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() != 3 {
+ return err_wrong_args("SMOVE");
+ }
+ let source = match extract_bytes(&args[0]) {
+ Some(k) => k.clone(),
+ None => return err_wrong_args("SMOVE"),
+ };
+ let destination = match extract_bytes(&args[1]) {
+ Some(k) => k.clone(),
+ None => return err_wrong_args("SMOVE"),
+ };
+ let member = match extract_bytes(&args[2]) {
+ Some(m) => m.clone(),
+ None => return err_wrong_args("SMOVE"),
+ };
+
+ match db.get_set(&source) {
+ Ok(None) => return Frame::Integer(0),
+ Err(e) => return e,
+ Ok(Some(_)) => {}
+ }
+ match db.get_set(&destination) {
+ Ok(_) => {}
+ Err(e) => return e,
+ }
+
+ if source == destination {
+ let src_set = match db.get_or_create_set(&source) {
+ Ok(s) => s,
+ Err(e) => return e,
+ };
+ return if src_set.contains(&member) {
+ Frame::Integer(1)
+ } else {
+ Frame::Integer(0)
+ };
+ }
+
+ let src_set = match db.get_or_create_set(&source) {
+ Ok(s) => s,
+ Err(e) => return e,
+ };
+ if !src_set.remove(&member) {
+ return Frame::Integer(0);
+ }
+ let src_empty = src_set.is_empty();
+
+ let dst_set = match db.get_or_create_set(&destination) {
+ Ok(s) => s,
+ Err(e) => return e,
+ };
+ dst_set.insert(member);
+
+ if src_empty {
+ db.remove(&source);
+ }
+
+ Frame::Integer(1)
+}
diff --git a/src/command/sorted_set/mod.rs b/src/command/sorted_set/mod.rs
index 23fd2f9f..ab6eace1 100644
--- a/src/command/sorted_set/mod.rs
+++ b/src/command/sorted_set/mod.rs
@@ -32,6 +32,28 @@ pub(super) fn format_score(score: f64) -> String {
}
}
+/// Zero-alloc version of `format_score` — returns `Bytes` directly.
+pub(crate) fn format_score_bytes(score: f64) -> Bytes {
+ if score == f64::INFINITY {
+ Bytes::from_static(b"inf")
+ } else if score == f64::NEG_INFINITY {
+ Bytes::from_static(b"-inf")
+ } else {
+ use std::fmt::Write;
+ let mut buf = String::with_capacity(24);
+ let _ = write!(buf, "{}", score);
+ Bytes::from(buf)
+ }
+}
+
+/// Aggregate operation for ZUNION/ZINTER/ZUNIONSTORE/ZINTERSTORE.
+#[derive(Debug, Clone, Copy)]
+pub(super) enum AggregateOp {
+ Sum,
+ Min,
+ Max,
+}
+
// ---------------------------------------------------------------------------
// Internal helpers -- CRITICAL for dual structure consistency
// ---------------------------------------------------------------------------
diff --git a/src/command/sorted_set/sorted_set_read.rs b/src/command/sorted_set/sorted_set_read.rs
index 455cfa82..a58ad576 100644
--- a/src/command/sorted_set/sorted_set_read.rs
+++ b/src/command/sorted_set/sorted_set_read.rs
@@ -8,9 +8,11 @@ use crate::storage::db::SortedSetRef;
use crate::command::helpers::{err, err_wrong_args, extract_bytes};
+use std::collections::HashMap;
+
use super::{
- format_score, glob_match, lex_in_range, parse_lex_bound, parse_score_bound, zrange_by_lex,
- zrange_by_rank, zrange_by_score, zrange_from_entries,
+ AggregateOp, format_score, format_score_bytes, glob_match, lex_in_range, parse_lex_bound,
+ parse_score_bound, zrange_by_lex, zrange_by_rank, zrange_by_score, zrange_from_entries,
};
// ---------------------------------------------------------------------------
@@ -1268,3 +1270,467 @@ pub fn zscan_readonly(db: &Database, args: &[Frame], now_ms: u64) -> Frame {
Err(e) => e,
}
}
+
+// ---------------------------------------------------------------------------
+// Shared helpers for ZDIFF / ZUNION / ZINTER (non-STORE variants)
+// ---------------------------------------------------------------------------
+
+/// Parse `numkeys k1 [k2 ...] [WEIGHTS ...] [AGGREGATE ...] [WITHSCORES]` args.
+fn parse_setop_args(
+ args: &[Frame],
+ cmd_name: &str,
+ supports_weights: bool,
+) -> Result<(Vec, Vec, AggregateOp, bool), Frame> {
+ if args.is_empty() {
+ return Err(err_wrong_args(cmd_name));
+ }
+ let numkeys_bytes = match extract_bytes(&args[0]) {
+ Some(b) => b,
+ None => return Err(err_wrong_args(cmd_name)),
+ };
+ let numkeys: usize = match std::str::from_utf8(numkeys_bytes)
+ .ok()
+ .and_then(|s| s.parse().ok())
+ {
+ Some(n) if n > 0 => n,
+ _ => return Err(err("ERR value is not an integer or out of range")),
+ };
+
+ if args.len() < 1 + numkeys {
+ return Err(err_wrong_args(cmd_name));
+ }
+
+ let keys: Vec = (0..numkeys)
+ .map(|j| {
+ extract_bytes(&args[1 + j])
+ .cloned()
+ .unwrap_or_else(Bytes::new)
+ })
+ .collect();
+
+ let mut weights: Vec = vec![1.0; numkeys];
+ let mut aggregate = AggregateOp::Sum;
+ let mut withscores = false;
+
+ let mut i = 1 + numkeys;
+ while i < args.len() {
+ let opt = match extract_bytes(&args[i]) {
+ Some(b) => b.as_ref(),
+ None => {
+ i += 1;
+ continue;
+ }
+ };
+ if supports_weights && opt.eq_ignore_ascii_case(b"WEIGHTS") {
+ for w in 0..numkeys {
+ if i + 1 + w >= args.len() {
+ return Err(err_wrong_args(cmd_name));
+ }
+ let wb = match extract_bytes(&args[i + 1 + w]) {
+ Some(b) => b,
+ None => return Err(err_wrong_args(cmd_name)),
+ };
+ let wval: f64 = match std::str::from_utf8(wb).ok().and_then(|s| s.parse().ok()) {
+ Some(v) => v,
+ None => return Err(err("ERR weight value is not a float")),
+ };
+ weights[w] = wval;
+ }
+ i += 1 + numkeys;
+ } else if supports_weights && opt.eq_ignore_ascii_case(b"AGGREGATE") {
+ if i + 1 >= args.len() {
+ return Err(err_wrong_args(cmd_name));
+ }
+ let agg_b = match extract_bytes(&args[i + 1]) {
+ Some(b) => b.as_ref(),
+ None => return Err(err_wrong_args(cmd_name)),
+ };
+ aggregate = if agg_b.eq_ignore_ascii_case(b"SUM") {
+ AggregateOp::Sum
+ } else if agg_b.eq_ignore_ascii_case(b"MIN") {
+ AggregateOp::Min
+ } else if agg_b.eq_ignore_ascii_case(b"MAX") {
+ AggregateOp::Max
+ } else {
+ return Err(err("ERR syntax error"));
+ };
+ i += 2;
+ } else if opt.eq_ignore_ascii_case(b"WITHSCORES") {
+ withscores = true;
+ i += 1;
+ } else {
+ i += 1;
+ }
+ }
+
+ Ok((keys, weights, aggregate, withscores))
+}
+
+/// Read all source sorted sets into temporary HashMaps.
+fn collect_source_sets(
+ db: &mut Database,
+ keys: &[Bytes],
+) -> Result>, Frame> {
+ let mut source_data: Vec> = Vec::with_capacity(keys.len());
+ for key in keys {
+ match db.get_sorted_set(key) {
+ Ok(Some((members, _))) => {
+ source_data.push(members.clone());
+ }
+ Ok(None) => {
+ source_data.push(HashMap::new());
+ }
+ Err(e) => return Err(e),
+ }
+ }
+ Ok(source_data)
+}
+
+/// Format a result map into a Frame::Array, optionally with scores.
+fn result_map_to_frame(result: &HashMap, withscores: bool) -> Frame {
+ let mut entries: Vec<(&Bytes, f64)> = result.iter().map(|(m, s)| (m, *s)).collect();
+ entries.sort_by(|a, b| {
+ a.1.partial_cmp(&b.1)
+ .unwrap_or(std::cmp::Ordering::Equal)
+ .then_with(|| a.0.cmp(b.0))
+ });
+ let cap = if withscores {
+ entries.len() * 2
+ } else {
+ entries.len()
+ };
+ let mut frames = Vec::with_capacity(cap);
+ for (member, score) in entries {
+ frames.push(Frame::BulkString(member.clone()));
+ if withscores {
+ frames.push(Frame::BulkString(format_score_bytes(score)));
+ }
+ }
+ Frame::Array(frames.into())
+}
+
+// ---------------------------------------------------------------------------
+// ZDIFF numkeys key [key ...] [WITHSCORES]
+// ---------------------------------------------------------------------------
+
+pub fn zdiff(db: &mut Database, args: &[Frame]) -> Frame {
+ let (keys, _, _, withscores) = match parse_setop_args(args, "ZDIFF", false) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+ let source_data = match collect_source_sets(db, &keys) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+ let mut result_map: HashMap = HashMap::new();
+ if let Some(first) = source_data.first() {
+ 'outer: for (member, score) in first {
+ for src in source_data.iter().skip(1) {
+ if src.contains_key(member) {
+ continue 'outer;
+ }
+ }
+ result_map.insert(member.clone(), *score);
+ }
+ }
+ result_map_to_frame(&result_map, withscores)
+}
+
+// ---------------------------------------------------------------------------
+// ZUNION numkeys key [key ...] [WEIGHTS ...] [AGGREGATE ...] [WITHSCORES]
+// ---------------------------------------------------------------------------
+
+pub fn zunion(db: &mut Database, args: &[Frame]) -> Frame {
+ let (keys, weights, aggregate, withscores) = match parse_setop_args(args, "ZUNION", true) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+ let source_data = match collect_source_sets(db, &keys) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+ let mut result_map: HashMap = HashMap::new();
+ for (idx, src) in source_data.iter().enumerate() {
+ for (member, score) in src {
+ let weighted = *score * weights[idx];
+ result_map
+ .entry(member.clone())
+ .and_modify(|existing| {
+ *existing = match aggregate {
+ AggregateOp::Sum => *existing + weighted,
+ AggregateOp::Min => existing.min(weighted),
+ AggregateOp::Max => existing.max(weighted),
+ };
+ })
+ .or_insert(weighted);
+ }
+ }
+ result_map_to_frame(&result_map, withscores)
+}
+
+// ---------------------------------------------------------------------------
+// ZINTER numkeys key [key ...] [WEIGHTS ...] [AGGREGATE ...] [WITHSCORES]
+// ---------------------------------------------------------------------------
+
+pub fn zinter(db: &mut Database, args: &[Frame]) -> Frame {
+ let (keys, weights, aggregate, withscores) = match parse_setop_args(args, "ZINTER", true) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+ let source_data = match collect_source_sets(db, &keys) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+ let mut result_map: HashMap = HashMap::new();
+ if let Some(first) = source_data.first() {
+ for (member, score) in first {
+ let weighted = *score * weights[0];
+ let mut final_score = weighted;
+ let mut in_all = true;
+ for (idx, src) in source_data.iter().enumerate().skip(1) {
+ match src.get(member) {
+ Some(s) => {
+ let ws = *s * weights[idx];
+ final_score = match aggregate {
+ AggregateOp::Sum => final_score + ws,
+ AggregateOp::Min => final_score.min(ws),
+ AggregateOp::Max => final_score.max(ws),
+ };
+ }
+ None => {
+ in_all = false;
+ break;
+ }
+ }
+ }
+ if in_all {
+ result_map.insert(member.clone(), final_score);
+ }
+ }
+ }
+ result_map_to_frame(&result_map, withscores)
+}
+
+// ---------------------------------------------------------------------------
+// ZINTERCARD numkeys key [key ...] [LIMIT n]
+// ---------------------------------------------------------------------------
+
+pub fn zintercard(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.is_empty() {
+ return err_wrong_args("ZINTERCARD");
+ }
+ let numkeys_bytes = match extract_bytes(&args[0]) {
+ Some(b) => b,
+ None => return err_wrong_args("ZINTERCARD"),
+ };
+ let numkeys: usize = match std::str::from_utf8(numkeys_bytes)
+ .ok()
+ .and_then(|s| s.parse().ok())
+ {
+ Some(n) if n > 0 => n,
+ _ => return err("ERR numkeys can't be non-positive value"),
+ };
+ if args.len() < 1 + numkeys {
+ return err_wrong_args("ZINTERCARD");
+ }
+ let keys: Vec = (0..numkeys)
+ .map(|j| {
+ extract_bytes(&args[1 + j])
+ .cloned()
+ .unwrap_or_else(Bytes::new)
+ })
+ .collect();
+ let mut limit: usize = 0;
+ let mut i = 1 + numkeys;
+ while i < args.len() {
+ let opt = match extract_bytes(&args[i]) {
+ Some(b) => b.as_ref(),
+ None => {
+ i += 1;
+ continue;
+ }
+ };
+ if opt.eq_ignore_ascii_case(b"LIMIT") {
+ if i + 1 >= args.len() {
+ return err_wrong_args("ZINTERCARD");
+ }
+ let lb = match extract_bytes(&args[i + 1]) {
+ Some(b) => b,
+ None => return err_wrong_args("ZINTERCARD"),
+ };
+ limit = match std::str::from_utf8(lb).ok().and_then(|s| s.parse().ok()) {
+ Some(v) => v,
+ None => return err("ERR value is not an integer or out of range"),
+ };
+ i += 2;
+ } else {
+ i += 1;
+ }
+ }
+ let source_data = match collect_source_sets(db, &keys) {
+ Ok(v) => v,
+ Err(e) => return e,
+ };
+ if source_data.iter().any(|s| s.is_empty()) {
+ return Frame::Integer(0);
+ }
+ let mut indices: Vec = (0..source_data.len()).collect();
+ indices.sort_by_key(|&i| source_data[i].len());
+ let smallest_idx = indices[0];
+ let mut count: i64 = 0;
+ for member in source_data[smallest_idx].keys() {
+ let mut in_all = true;
+ for &idx in indices.iter().skip(1) {
+ if !source_data[idx].contains_key(member) {
+ in_all = false;
+ break;
+ }
+ }
+ if in_all {
+ count += 1;
+ if limit > 0 && count >= limit as i64 {
+ break;
+ }
+ }
+ }
+ Frame::Integer(count)
+}
+
+// ---------------------------------------------------------------------------
+// ZMSCORE key member [member ...]
+// ---------------------------------------------------------------------------
+
+pub fn zmscore(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() < 2 {
+ return err_wrong_args("ZMSCORE");
+ }
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("ZMSCORE"),
+ };
+ match db.get_sorted_set(key) {
+ Ok(Some((members, _))) => {
+ let mut result = Vec::with_capacity(args.len() - 1);
+ for arg in &args[1..] {
+ let member = match extract_bytes(arg) {
+ Some(m) => m,
+ None => {
+ result.push(Frame::Null);
+ continue;
+ }
+ };
+ match members.get(member) {
+ Some(score) => {
+ result.push(Frame::BulkString(format_score_bytes(*score)));
+ }
+ None => result.push(Frame::Null),
+ }
+ }
+ Frame::Array(result.into())
+ }
+ Ok(None) => {
+ let mut result = Vec::with_capacity(args.len() - 1);
+ for _ in &args[1..] {
+ result.push(Frame::Null);
+ }
+ Frame::Array(result.into())
+ }
+ Err(e) => e,
+ }
+}
+
+// ---------------------------------------------------------------------------
+// ZRANDMEMBER key [count [WITHSCORES]]
+// ---------------------------------------------------------------------------
+
+pub fn zrandmember(db: &mut Database, args: &[Frame]) -> Frame {
+ use rand::seq::IndexedRandom;
+ if args.is_empty() || args.len() > 3 {
+ return err_wrong_args("ZRANDMEMBER");
+ }
+ let key = match extract_bytes(&args[0]) {
+ Some(k) => k,
+ None => return err_wrong_args("ZRANDMEMBER"),
+ };
+ let (members_map, _) = match db.get_sorted_set(key) {
+ Ok(Some(pair)) => pair,
+ Ok(None) => {
+ return if args.len() == 1 {
+ Frame::Null
+ } else {
+ Frame::Array(framevec![])
+ };
+ }
+ Err(e) => return e,
+ };
+ if members_map.is_empty() {
+ return if args.len() == 1 {
+ Frame::Null
+ } else {
+ Frame::Array(framevec![])
+ };
+ }
+ let entries: Vec<(&Bytes, f64)> = members_map.iter().map(|(m, s)| (m, *s)).collect();
+ let mut rng = rand::rng();
+ if args.len() == 1 {
+ return if let Some(chosen) = entries.choose(&mut rng) {
+ Frame::BulkString(chosen.0.clone())
+ } else {
+ Frame::Null
+ };
+ }
+ let count_bytes = match extract_bytes(&args[1]) {
+ Some(b) => b,
+ None => return err_wrong_args("ZRANDMEMBER"),
+ };
+ let count: i64 = match std::str::from_utf8(count_bytes)
+ .ok()
+ .and_then(|s| s.parse().ok())
+ {
+ Some(c) => c,
+ None => return err("ERR value is not an integer or out of range"),
+ };
+ let withscores = if args.len() == 3 {
+ let opt = match extract_bytes(&args[2]) {
+ Some(b) => b,
+ None => return err("ERR syntax error"),
+ };
+ if opt.eq_ignore_ascii_case(b"WITHSCORES") {
+ true
+ } else {
+ return err("ERR syntax error");
+ }
+ } else {
+ false
+ };
+ if count == 0 {
+ return Frame::Array(framevec![]);
+ }
+ if count > 0 {
+ let n = std::cmp::min(count as usize, entries.len());
+ let chosen: Vec<&(&Bytes, f64)> = entries.sample(&mut rng, n).collect();
+ let cap = if withscores { n * 2 } else { n };
+ let mut result = Vec::with_capacity(cap);
+ for (member, score) in chosen {
+ result.push(Frame::BulkString((*member).clone()));
+ if withscores {
+ result.push(Frame::BulkString(format_score_bytes(*score)));
+ }
+ }
+ Frame::Array(result.into())
+ } else {
+ // Negative count: allow duplicates. Cap to prevent OOM on extreme values.
+ let n = std::cmp::min(count.unsigned_abs() as usize, entries.len() * 10);
+ let cap = if withscores { n * 2 } else { n };
+ let mut result = Vec::with_capacity(cap);
+ for _ in 0..n {
+ if let Some(chosen) = entries.choose(&mut rng) {
+ result.push(Frame::BulkString(chosen.0.clone()));
+ if withscores {
+ result.push(Frame::BulkString(format_score_bytes(chosen.1)));
+ }
+ }
+ }
+ Frame::Array(result.into())
+ }
+}
diff --git a/src/command/sorted_set/sorted_set_write.rs b/src/command/sorted_set/sorted_set_write.rs
index 0b3973dd..8a073280 100644
--- a/src/command/sorted_set/sorted_set_write.rs
+++ b/src/command/sorted_set/sorted_set_write.rs
@@ -6,7 +6,10 @@ use crate::storage::Database;
use crate::command::helpers::{err, err_wrong_args, extract_bytes};
-use super::{format_score, zadd_member, zrem_member};
+use super::{
+ AggregateOp, format_score, format_score_bytes, zadd_member, zrange_by_lex, zrange_by_rank,
+ zrange_by_score, zrem_member,
+};
// ---------------------------------------------------------------------------
// Write commands (mutate the database)
@@ -333,13 +336,6 @@ pub fn zinterstore(db: &mut Database, args: &[Frame]) -> Frame {
zstore_impl(db, args, true)
}
-#[derive(Debug, Clone, Copy)]
-enum AggregateOp {
- Sum,
- Min,
- Max,
-}
-
fn zstore_impl(db: &mut Database, args: &[Frame], intersect: bool) -> Frame {
let cmd_name = if intersect {
"ZINTERSTORE"
@@ -514,3 +510,288 @@ fn zstore_impl(db: &mut Database, args: &[Frame], intersect: bool) -> Frame {
Frame::Integer(result_size)
}
+
+// ---------------------------------------------------------------------------
+// ZRANGESTORE dst src min max [BYSCORE | BYLEX] [REV] [LIMIT offset count]
+// ---------------------------------------------------------------------------
+
+/// ZRANGESTORE dst src min max [BYSCORE | BYLEX] [REV] [LIMIT offset count]
+///
+/// Stores the result of a ZRANGE into `dst`, replacing it. Returns the cardinality of `dst`.
+pub fn zrangestore(db: &mut Database, args: &[Frame]) -> Frame {
+ if args.len() < 4 {
+ return err_wrong_args("ZRANGESTORE");
+ }
+ let dst = match extract_bytes(&args[0]) {
+ Some(k) => k.clone(),
+ None => return err_wrong_args("ZRANGESTORE"),
+ };
+ let src = match extract_bytes(&args[1]) {
+ Some(k) => k,
+ None => return err_wrong_args("ZRANGESTORE"),
+ };
+ let min_arg = match extract_bytes(&args[2]) {
+ Some(b) => b.clone(),
+ None => return err_wrong_args("ZRANGESTORE"),
+ };
+ let max_arg = match extract_bytes(&args[3]) {
+ Some(b) => b.clone(),
+ None => return err_wrong_args("ZRANGESTORE"),
+ };
+
+ // Parse optional flags (same as ZRANGE but no WITHSCORES)
+ let mut by_score = false;
+ let mut by_lex = false;
+ let mut rev = false;
+ let mut limit_offset: Option = None;
+ let mut limit_count: Option = None;
+
+ let mut i = 4;
+ while i < args.len() {
+ let opt = match extract_bytes(&args[i]) {
+ Some(b) => b.as_ref(),
+ None => {
+ i += 1;
+ continue;
+ }
+ };
+ if opt.eq_ignore_ascii_case(b"BYSCORE") {
+ by_score = true;
+ i += 1;
+ } else if opt.eq_ignore_ascii_case(b"BYLEX") {
+ by_lex = true;
+ i += 1;
+ } else if opt.eq_ignore_ascii_case(b"REV") {
+ rev = true;
+ i += 1;
+ } else if opt.eq_ignore_ascii_case(b"LIMIT") {
+ if i + 2 < args.len() {
+ let off_b = match extract_bytes(&args[i + 1]) {
+ Some(b) => b,
+ None => return err_wrong_args("ZRANGESTORE"),
+ };
+ let cnt_b = match extract_bytes(&args[i + 2]) {
+ Some(b) => b,
+ None => return err_wrong_args("ZRANGESTORE"),
+ };
+ limit_offset = std::str::from_utf8(off_b).ok().and_then(|s| s.parse().ok());
+ limit_count = std::str::from_utf8(cnt_b).ok().and_then(|s| s.parse().ok());
+ if limit_offset.is_none() || limit_count.is_none() {
+ return err("ERR value is not an integer or out of range");
+ }
+ i += 3;
+ } else {
+ return err_wrong_args("ZRANGESTORE");
+ }
+ } else {
+ return err("ERR syntax error");
+ }
+ }
+
+ if by_score && by_lex {
+ return err("ERR BYSCORE and BYLEX options are not compatible");
+ }
+ if limit_offset.is_some() && !by_score && !by_lex {
+ return err(
+ "ERR syntax error, LIMIT is only supported in combination with either BYSCORE or BYLEX",
+ );
+ }
+
+ // Run ZRANGE on src, collecting (member, score) pairs
+ let entries: Vec<(Bytes, f64)> = match db.get_sorted_set(src) {
+ Ok(Some((members, scores))) => {
+ let frame = if by_score {
+ zrange_by_score(
+ members,
+ scores,
+ &min_arg,
+ &max_arg,
+ rev,
+ true,
+ limit_offset,
+ limit_count,
+ )
+ } else if by_lex {
+ zrange_by_lex(
+ scores,
+ &min_arg,
+ &max_arg,
+ rev,
+ true,
+ members,
+ limit_offset,
+ limit_count,
+ )
+ } else {
+ zrange_by_rank(scores, &min_arg, &max_arg, rev, true)
+ };
+ // Parse the Frame::Array([member, score, member, score, ...]) into Vec<(Bytes, f64)>
+ match frame {
+ Frame::Array(arr) => {
+ let mut result = Vec::with_capacity(arr.len() / 2);
+ let mut idx = 0;
+ while idx + 1 < arr.len() {
+ if let (Frame::BulkString(m), Frame::BulkString(s)) =
+ (&arr[idx], &arr[idx + 1])
+ {
+ if let Ok(score) = std::str::from_utf8(s).unwrap_or("0").parse::()
+ {
+ result.push((m.clone(), score));
+ }
+ }
+ idx += 2;
+ }
+ result
+ }
+ Frame::Error(_) => return frame,
+ _ => Vec::with_capacity(0),
+ }
+ }
+ Ok(None) => Vec::with_capacity(0),
+ Err(e) => return e,
+ };
+
+ let count = entries.len() as i64;
+
+ // Replace dst with the result
+ db.remove(&dst);
+
+ if !entries.is_empty() {
+ let (dst_members, dst_scores) = match db.get_or_create_sorted_set(&dst) {
+ Ok(pair) => pair,
+ Err(e) => return e,
+ };
+ for (member, score) in entries {
+ zadd_member(dst_members, dst_scores, member, score);
+ }
+ }
+
+ Frame::Integer(count)
+}
+
+// ---------------------------------------------------------------------------
+// ZMPOP numkeys key [key ...] MIN|MAX [COUNT n]
+// ---------------------------------------------------------------------------
+
+/// ZMPOP numkeys key [key ...] MIN|MAX [COUNT n]
+///
+/// Pops elements from the first non-empty sorted set. Returns [key, [[m, s], ...]].
+pub fn zmpop(db: &mut Database, args: &[Frame]) -> Frame {
+ use crate::framevec;
+ if args.len() < 3 {
+ return err_wrong_args("ZMPOP");
+ }
+ let numkeys_bytes = match extract_bytes(&args[0]) {
+ Some(b) => b,
+ None => return err_wrong_args("ZMPOP"),
+ };
+ let numkeys: usize = match std::str::from_utf8(numkeys_bytes)
+ .ok()
+ .and_then(|s| s.parse().ok())
+ {
+ Some(n) if n > 0 => n,
+ _ => return err("ERR numkeys can't be non-positive value"),
+ };
+
+ if args.len() < 1 + numkeys + 1 {
+ return err_wrong_args("ZMPOP");
+ }
+
+ let keys: Vec = (0..numkeys)
+ .map(|j| {
+ extract_bytes(&args[1 + j])
+ .cloned()
+ .unwrap_or_else(Bytes::new)
+ })
+ .collect();
+
+ // Parse MIN|MAX
+ let direction_bytes = match extract_bytes(&args[1 + numkeys]) {
+ Some(b) => b.as_ref(),
+ None => return err_wrong_args("ZMPOP"),
+ };
+ let is_min = if direction_bytes.eq_ignore_ascii_case(b"MIN") {
+ true
+ } else if direction_bytes.eq_ignore_ascii_case(b"MAX") {
+ false
+ } else {
+ return err("ERR syntax error");
+ };
+
+ // Parse optional COUNT
+ let mut pop_count: usize = 1;
+ let mut i = 2 + numkeys;
+ while i < args.len() {
+ let opt = match extract_bytes(&args[i]) {
+ Some(b) => b.as_ref(),
+ None => {
+ i += 1;
+ continue;
+ }
+ };
+ if opt.eq_ignore_ascii_case(b"COUNT") {
+ if i + 1 >= args.len() {
+ return err_wrong_args("ZMPOP");
+ }
+ let cb = match extract_bytes(&args[i + 1]) {
+ Some(b) => b,
+ None => return err_wrong_args("ZMPOP"),
+ };
+ pop_count = match std::str::from_utf8(cb).ok().and_then(|s| s.parse().ok()) {
+ Some(c) if c > 0 => c,
+ _ => return err("ERR value is not an integer or out of range"),
+ };
+ i += 2;
+ } else {
+ i += 1;
+ }
+ }
+
+ // Iterate keys, find first non-empty
+ for key in &keys {
+ let card = match db.get_sorted_set(key) {
+ Ok(Some((members, _))) => members.len(),
+ Ok(None) => 0,
+ Err(e) => return e,
+ };
+ if card == 0 {
+ continue;
+ }
+
+ let (members, scores) = match db.get_or_create_sorted_set(key) {
+ Ok(pair) => pair,
+ Err(e) => return e,
+ };
+
+ let mut popped = Vec::with_capacity(pop_count);
+ for _ in 0..pop_count {
+ let entry = if is_min {
+ scores.iter().next().map(|(s, m)| (s, m.clone()))
+ } else {
+ scores.iter_rev().next().map(|(s, m)| (s, m.clone()))
+ };
+ match entry {
+ Some((score, member)) => {
+ scores.remove(score, &member);
+ members.remove(&member);
+ popped.push(Frame::Array(framevec![
+ Frame::BulkString(member),
+ Frame::BulkString(format_score_bytes(score.0)),
+ ]));
+ }
+ None => break,
+ }
+ }
+
+ if members.is_empty() {
+ db.remove(key);
+ }
+
+ return Frame::Array(framevec![
+ Frame::BulkString(key.clone()),
+ Frame::Array(popped.into()),
+ ]);
+ }
+
+ Frame::Null
+}
diff --git a/src/scripting/bridge.rs b/src/scripting/bridge.rs
index 8ac58da6..c8b0a283 100644
--- a/src/scripting/bridge.rs
+++ b/src/scripting/bridge.rs
@@ -22,6 +22,8 @@ thread_local! {
static CURRENT_DB_COUNT: Cell = const { Cell::new(1) };
/// Whether this script execution has performed any write commands.
static SCRIPT_HAD_WRITE: Cell = const { Cell::new(false) };
+ /// Whether this script is running in read-only mode (FCALL_RO).
+ static SCRIPT_READ_ONLY: Cell = const { Cell::new(false) };
}
/// Set the thread-local database pointer before script execution.
@@ -35,6 +37,17 @@ pub fn set_script_db(db: &mut crate::storage::Database, db_idx: usize, db_count:
/// Clear the thread-local database pointer after script execution.
pub fn clear_script_db() {
CURRENT_DB.with(|c| c.set(std::ptr::null_mut()));
+ SCRIPT_READ_ONLY.with(|c| c.set(false));
+}
+
+/// Set the read-only flag for the current script execution (FCALL_RO).
+pub fn set_script_read_only(read_only: bool) {
+ SCRIPT_READ_ONLY.with(|c| c.set(read_only));
+}
+
+/// Check whether the current script execution is in read-only mode.
+pub fn is_script_read_only() -> bool {
+ SCRIPT_READ_ONLY.with(|c| c.get())
}
/// Check whether the current script execution has performed any write commands.
@@ -84,8 +97,18 @@ pub fn make_redis_call_fn(lua: &Lua, propagate_errors: bool) -> mlua::Result,
+ /// Flags controlling execution semantics.
+ pub flags: u8,
+}
+
+/// Function flag constants (mirrors Redis function flags).
+pub mod func_flags {
+ pub const NO_WRITES: u8 = 0b0001;
+ pub const ALLOW_OOM: u8 = 0b0010;
+ pub const ALLOW_STALE: u8 = 0b0100;
+ pub const NO_CLUSTER: u8 = 0b1000;
+}
+
+/// A loaded library containing one or more functions.
+pub struct Library {
+ /// Library name (from shebang `name=`).
+ pub name: Bytes,
+ /// Engine identifier (always `"lua"` for now).
+ pub engine: Bytes,
+ /// Original source body (retained for FUNCTION LIST WITHCODE).
+ pub source: Bytes,
+ /// Registered functions keyed by function name.
+ pub functions: HashMap,
+ /// Per-library Lua state (holds the compiled function closures).
+ pub lua: Rc,
+}
+
+/// Errors from `FunctionRegistry::load`.
+#[derive(Debug)]
+pub enum LoadError {
+ /// Body does not start with `#!lua name=...` shebang.
+ MissingShebang,
+ /// Unsupported engine (only `lua` is supported).
+ BadEngine(String),
+ /// Library already loaded and REPLACE was not specified.
+ AlreadyExists(Bytes),
+ /// Lua compilation or evaluation error.
+ LuaError(String),
+ /// No functions were registered by the library body.
+ NoFunctions,
+}
+
+impl LoadError {
+ /// Convert to a Redis error Frame.
+ pub fn into_frame(self) -> Frame {
+ match self {
+ LoadError::MissingShebang => {
+ Frame::Error(Bytes::from_static(b"ERR Missing library metadata"))
+ }
+ LoadError::BadEngine(e) => {
+ Frame::Error(Bytes::from(format!("ERR Engine '{e}' not found")))
+ }
+ LoadError::AlreadyExists(name) => Frame::Error(Bytes::from(format!(
+ "ERR Library '{}' already exists",
+ String::from_utf8_lossy(&name)
+ ))),
+ LoadError::LuaError(e) => Frame::Error(Bytes::from(format!("ERR {e}"))),
+ LoadError::NoFunctions => {
+ Frame::Error(Bytes::from_static(b"ERR No functions registered"))
+ }
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+
+/// Per-shard function registry. NOT behind a lock -- single-threaded shard access.
+pub struct FunctionRegistry {
+ /// Libraries keyed by library name.
+ libraries: HashMap,
+ /// Reverse index: function_name -> library_name (for fast FCALL lookup).
+ func_to_lib: HashMap,
+}
+
+impl FunctionRegistry {
+ pub fn new() -> Self {
+ FunctionRegistry {
+ libraries: HashMap::new(),
+ func_to_lib: HashMap::new(),
+ }
+ }
+
+ /// Load a library from its body text.
+ ///
+ /// The body must start with a shebang line: `#!lua name=`.
+ /// The remaining body is evaluated in a sandboxed Lua VM. Calls to
+ /// `redis.register_function(name, fn)` register functions.
+ ///
+ /// If `replace` is true, an existing library with the same name is replaced.
+ /// Maximum function body size (512 KB, matching Redis default proto-max-bulk-len).
+ const MAX_BODY_SIZE: usize = 512 * 1024;
+
+ pub fn load(&mut self, body: &[u8], replace: bool) -> Result {
+ if body.len() > Self::MAX_BODY_SIZE {
+ return Err(LoadError::LuaError(format!(
+ "Function body too large ({} bytes, max {})",
+ body.len(),
+ Self::MAX_BODY_SIZE
+ )));
+ }
+ let (lib_name, _rest) = parse_shebang(body)?;
+
+ // Check for existing library
+ if !replace && self.libraries.contains_key(&lib_name) {
+ return Err(LoadError::AlreadyExists(lib_name));
+ }
+
+ // Create the library via Lua evaluation
+ let library = self.create_library(lib_name.clone(), body)?;
+
+ // Check for function name collisions with other libraries BEFORE removing old
+ for func_name in library.functions.keys() {
+ if let Some(other_lib) = self.func_to_lib.get(func_name) {
+ if *other_lib != lib_name {
+ return Err(LoadError::LuaError(format!(
+ "Function '{}' already exists in library '{}'",
+ String::from_utf8_lossy(func_name),
+ String::from_utf8_lossy(other_lib),
+ )));
+ }
+ }
+ }
+
+ // Remove old library if replacing (safe now — collision check passed)
+ if let Some(old) = self.libraries.remove(&lib_name) {
+ for func_name in old.functions.keys() {
+ self.func_to_lib.remove(func_name);
+ }
+ }
+
+ // Register reverse index
+ for func_name in library.functions.keys() {
+ self.func_to_lib.insert(func_name.clone(), lib_name.clone());
+ }
+
+ self.libraries.insert(lib_name.clone(), library);
+ Ok(lib_name)
+ }
+
+ /// Look up a function by name. Returns the library and function definition
+ /// if found.
+ pub fn lookup(&self, func_name: &[u8]) -> Option<(&Library, &FunctionDef)> {
+ let lib_name = self.func_to_lib.get(func_name)?;
+ let lib = self.libraries.get(lib_name)?;
+ let func = lib.functions.get(func_name)?;
+ Some((lib, func))
+ }
+
+ /// List all loaded libraries.
+ pub fn list(&self) -> Vec<&Library> {
+ self.libraries.values().collect()
+ }
+
+ /// Delete a library by name. Returns true if it existed.
+ pub fn delete(&mut self, lib_name: &[u8]) -> bool {
+ if let Some(lib) = self.libraries.remove(lib_name) {
+ for func_name in lib.functions.keys() {
+ self.func_to_lib.remove(func_name);
+ }
+ true
+ } else {
+ false
+ }
+ }
+
+ /// Flush all libraries.
+ pub fn flush(&mut self) {
+ self.libraries.clear();
+ self.func_to_lib.clear();
+ }
+
+ /// Execute a function by name with the given keys and args.
+ pub fn call_function(
+ &self,
+ func_name: &[u8],
+ keys: Vec,
+ argv: Vec,
+ db: &mut Database,
+ selected_db: usize,
+ db_count: usize,
+ read_only: bool,
+ ) -> Frame {
+ let (lib, _func_def) = match self.lookup(func_name) {
+ Some(pair) => pair,
+ None => {
+ return Frame::Error(Bytes::from_static(b"ERR Function not found"));
+ }
+ };
+
+ // Set up bridge
+ crate::scripting::bridge::set_script_db(db, selected_db, db_count);
+ if read_only {
+ crate::scripting::bridge::set_script_read_only(true);
+ }
+
+ let timeout = std::time::Duration::from_secs(5);
+ if crate::scripting::sandbox::install_timeout_hook(&lib.lua, timeout).is_err() {
+ crate::scripting::bridge::clear_script_db();
+ return Frame::Error(Bytes::from_static(
+ b"ERR Failed to install script timeout hook",
+ ));
+ }
+
+ let result = (|| -> mlua::Result {
+ // Set KEYS and ARGV globals
+ let keys_table = lib.lua.create_table()?;
+ for (i, key) in keys.iter().enumerate() {
+ keys_table.set(i as i64 + 1, lib.lua.create_string(key.as_ref())?)?;
+ }
+ lib.lua.globals().set("KEYS", keys_table)?;
+
+ let argv_table = lib.lua.create_table()?;
+ for (i, arg) in argv.iter().enumerate() {
+ argv_table.set(i as i64 + 1, lib.lua.create_string(arg.as_ref())?)?;
+ }
+ lib.lua.globals().set("ARGV", argv_table)?;
+
+ // Call the registered function
+ let func_name_str = lib.lua.create_string(func_name)?;
+ let func_tbl: mlua::Table = lib.lua.globals().get("__moon_functions")?;
+ let registered: mlua::Function = func_tbl.get(func_name_str)?;
+ let val: LuaValue = registered.call(())?;
+ crate::scripting::types::lua_value_to_frame(&lib.lua, &val)
+ })();
+
+ // Always clean up
+ crate::scripting::sandbox::remove_timeout_hook(&lib.lua);
+ crate::scripting::bridge::clear_script_db();
+
+ match result {
+ Ok(frame) => frame,
+ Err(mlua::Error::RuntimeError(msg)) if msg.contains("ERR Lua script timeout") => {
+ Frame::Error(Bytes::from_static(b"BUSY Lua script timeout exceeded"))
+ }
+ Err(mlua::Error::RuntimeError(msg))
+ if msg.contains("Write commands are not allowed") =>
+ {
+ Frame::Error(Bytes::from_static(
+ b"ERR Write commands are not allowed from read-only scripts",
+ ))
+ }
+ Err(e) => Frame::Error(Bytes::from(format!("ERR Error running script: {e}"))),
+ }
+ }
+
+ /// Internal: create a Library from body bytes by evaluating in a Lua sandbox.
+ fn create_library(&self, lib_name: Bytes, body: &[u8]) -> Result {
+ let (_, rest) = parse_shebang(body)?;
+
+ // Create a new sandboxed Lua VM
+ let lua = Rc::new(mlua::Lua::new());
+ crate::scripting::sandbox::setup_sandbox(&lua)
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+ crate::scripting::sandbox::register_redis_api(&lua)
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+
+ // Create a table to store registered functions
+ let func_table = lua
+ .create_table()
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+ lua.globals()
+ .set("__moon_functions", func_table)
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+
+ // Create shared storage for function metadata
+ let functions: Rc>> =
+ Rc::new(RefCell::new(HashMap::new()));
+
+ // Create redis.register_function
+ let funcs_clone = functions.clone();
+ let register_fn = lua
+ .create_function(move |lua, args: LuaMultiValue| {
+ // Two forms:
+ // 1. redis.register_function("name", function) -- positional
+ // 2. redis.register_function({function_name="name", callback=fn, ...})
+
+ if args.is_empty() {
+ return Err(mlua::Error::RuntimeError(
+ "ERR redis.register_function requires at least one argument".to_string(),
+ ));
+ }
+
+ let (name, callback, description, flags) = match &args[0] {
+ LuaValue::String(s) => {
+ // Positional form: (name, fn)
+ if args.len() < 2 {
+ return Err(mlua::Error::RuntimeError(
+ "ERR redis.register_function requires a function argument"
+ .to_string(),
+ ));
+ }
+ let func = match &args[1] {
+ LuaValue::Function(f) => f.clone(),
+ _ => {
+ return Err(mlua::Error::RuntimeError(
+ "ERR redis.register_function second argument \
+ must be a function"
+ .to_string(),
+ ));
+ }
+ };
+ let name_bytes = s.as_bytes();
+ (Bytes::copy_from_slice(&name_bytes), func, None, 0u8)
+ }
+ LuaValue::Table(t) => {
+ // Table form
+ let name_s: mlua::String = t.get("function_name").map_err(|_| {
+ mlua::Error::RuntimeError(
+ "ERR redis.register_function: table must \
+ have function_name"
+ .to_string(),
+ )
+ })?;
+ let callback: mlua::Function = t.get("callback").map_err(|_| {
+ mlua::Error::RuntimeError(
+ "ERR redis.register_function: table must \
+ have callback"
+ .to_string(),
+ )
+ })?;
+ let desc: Option = t.get("description").ok();
+ let mut flags: u8 = 0;
+ if let Ok(f) = t.get::("flags") {
+ for pair in f.sequence_values::() {
+ if let Ok(flag_str) = pair {
+ let flag_bytes = flag_str.as_bytes();
+ if &*flag_bytes == b"no-writes" {
+ flags |= func_flags::NO_WRITES;
+ } else if &*flag_bytes == b"allow-oom" {
+ flags |= func_flags::ALLOW_OOM;
+ } else if &*flag_bytes == b"allow-stale" {
+ flags |= func_flags::ALLOW_STALE;
+ } else if &*flag_bytes == b"no-cluster" {
+ flags |= func_flags::NO_CLUSTER;
+ }
+ }
+ }
+ }
+ let nb = name_s.as_bytes();
+ (Bytes::copy_from_slice(&nb), callback, desc, flags)
+ }
+ _ => {
+ return Err(mlua::Error::RuntimeError(
+ "ERR redis.register_function first argument \
+ must be a string or table"
+ .to_string(),
+ ));
+ }
+ };
+
+ // Store callback in __moon_functions table for FCALL
+ let ftbl: mlua::Table = lua
+ .globals()
+ .get("__moon_functions")
+ .map_err(|_| mlua::Error::RuntimeError("internal error".to_string()))?;
+ ftbl.set(lua.create_string(name.as_ref())?, callback)?;
+
+ // Store metadata
+ funcs_clone.borrow_mut().insert(
+ name.clone(),
+ FunctionDef {
+ name,
+ description,
+ flags,
+ },
+ );
+
+ Ok(())
+ })
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+
+ // Set redis.register_function
+ let redis_table: mlua::Table = lua
+ .globals()
+ .get("redis")
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+ redis_table
+ .set("register_function", register_fn)
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+
+ // Evaluate the library body (everything after shebang)
+ lua.load(rest)
+ .exec()
+ .map_err(|e| LoadError::LuaError(e.to_string()))?;
+
+ let functions = Rc::try_unwrap(functions)
+ .map(|cell| cell.into_inner())
+ .unwrap_or_else(|rc| rc.borrow().clone());
+
+ if functions.is_empty() {
+ return Err(LoadError::NoFunctions);
+ }
+
+ Ok(Library {
+ name: lib_name,
+ engine: Bytes::from_static(b"lua"),
+ source: Bytes::copy_from_slice(body),
+ functions,
+ lua,
+ })
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Shebang parser
+// ---------------------------------------------------------------------------
+
+/// Parse the shebang line from a FUNCTION LOAD body.
+///
+/// Expected format: `#! name=\n`
+/// Returns `(libname, rest_of_body)`.
+pub fn parse_shebang(body: &[u8]) -> Result<(Bytes, &[u8]), LoadError> {
+ // Find first newline
+ let newline_pos = body
+ .iter()
+ .position(|&b| b == b'\n')
+ .ok_or(LoadError::MissingShebang)?;
+
+ let first_line = &body[..newline_pos];
+ let rest = &body[newline_pos + 1..];
+
+ // Must start with #!
+ if !first_line.starts_with(b"#!") {
+ return Err(LoadError::MissingShebang);
+ }
+
+ let header = &first_line[2..];
+
+ // Parse engine and key=value pairs
+ let header_str = std::str::from_utf8(header).map_err(|_| LoadError::MissingShebang)?;
+
+ let mut parts = header_str.split_whitespace();
+ let engine = parts.next().ok_or(LoadError::MissingShebang)?;
+
+ if engine != "lua" {
+ return Err(LoadError::BadEngine(engine.to_string()));
+ }
+
+ // Find name=
+ let mut lib_name: Option<&str> = None;
+ for part in parts {
+ if let Some(val) = part.strip_prefix("name=") {
+ lib_name = Some(val);
+ }
+ }
+
+ let name = lib_name.ok_or(LoadError::MissingShebang)?;
+ if name.is_empty() {
+ return Err(LoadError::MissingShebang);
+ }
+
+ Ok((Bytes::copy_from_slice(name.as_bytes()), rest))
+}
+
+// ---------------------------------------------------------------------------
+// Unit tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_parse_shebang_basic() {
+ let body = b"#!lua name=mylib\nreturn 1";
+ let (name, rest) = parse_shebang(body).unwrap();
+ assert_eq!(name, Bytes::from_static(b"mylib"));
+ assert_eq!(rest, b"return 1");
+ }
+
+ #[test]
+ fn test_parse_shebang_missing() {
+ let body = b"return 1";
+ assert!(parse_shebang(body).is_err());
+ }
+
+ #[test]
+ fn test_parse_shebang_bad_engine() {
+ let body = b"#!python name=mylib\nreturn 1";
+ match parse_shebang(body) {
+ Err(LoadError::BadEngine(e)) => assert_eq!(e, "python"),
+ other => panic!("Expected BadEngine, got {:?}", other.err()),
+ }
+ }
+
+ #[test]
+ fn test_parse_shebang_no_name() {
+ let body = b"#!lua\nreturn 1";
+ assert!(matches!(
+ parse_shebang(body),
+ Err(LoadError::MissingShebang)
+ ));
+ }
+
+ #[test]
+ fn test_load_and_lookup() {
+ let mut reg = FunctionRegistry::new();
+ let body =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+ let name = reg.load(body, false).unwrap();
+ assert_eq!(name, Bytes::from_static(b"mylib"));
+
+ let (lib, func) = reg.lookup(b"hello").unwrap();
+ assert_eq!(lib.name, Bytes::from_static(b"mylib"));
+ assert_eq!(func.name, Bytes::from_static(b"hello"));
+ }
+
+ #[test]
+ fn test_load_duplicate_without_replace() {
+ let mut reg = FunctionRegistry::new();
+ let body =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+ reg.load(body, false).unwrap();
+ assert!(matches!(
+ reg.load(body, false),
+ Err(LoadError::AlreadyExists(_))
+ ));
+ }
+
+ #[test]
+ fn test_load_replace() {
+ let mut reg = FunctionRegistry::new();
+ let body1 =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+ let body2 =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'replaced' end)";
+ reg.load(body1, false).unwrap();
+ reg.load(body2, true).unwrap();
+ assert!(reg.lookup(b"hello").is_some());
+ }
+
+ #[test]
+ fn test_delete() {
+ let mut reg = FunctionRegistry::new();
+ let body =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+ reg.load(body, false).unwrap();
+ assert!(reg.delete(b"mylib"));
+ assert!(reg.lookup(b"hello").is_none());
+ }
+
+ #[test]
+ fn test_flush() {
+ let mut reg = FunctionRegistry::new();
+ let body =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+ reg.load(body, false).unwrap();
+ reg.flush();
+ assert!(reg.list().is_empty());
+ }
+
+ #[test]
+ fn test_list() {
+ let mut reg = FunctionRegistry::new();
+ let body =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+ reg.load(body, false).unwrap();
+ let libs = reg.list();
+ assert_eq!(libs.len(), 1);
+ assert_eq!(libs[0].name, Bytes::from_static(b"mylib"));
+ }
+
+ #[test]
+ fn test_table_form_registration() {
+ let mut reg = FunctionRegistry::new();
+ let body = b"#!lua name=mylib\nredis.register_function{function_name='hello', callback=function() return 'world' end, description='test func'}";
+ let name = reg.load(body, false).unwrap();
+ assert_eq!(name, Bytes::from_static(b"mylib"));
+ let (_lib, func) = reg.lookup(b"hello").unwrap();
+ assert_eq!(func.description.as_deref(), Some("test func"));
+ }
+
+ #[test]
+ fn test_call_function() {
+ let mut reg = FunctionRegistry::new();
+ let body =
+ b"#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+ reg.load(body, false).unwrap();
+
+ let mut db = Database::new();
+ let result = reg.call_function(b"hello", vec![], vec![], &mut db, 0, 1, false);
+ assert!(matches!(result, Frame::BulkString(ref b) if *b == Bytes::from_static(b"world")));
+ }
+
+ #[test]
+ fn test_call_function_not_found() {
+ let reg = FunctionRegistry::new();
+ let mut db = Database::new();
+ let result = reg.call_function(b"nonexistent", vec![], vec![], &mut db, 0, 1, false);
+ assert!(matches!(result, Frame::Error(_)));
+ }
+}
diff --git a/src/scripting/mod.rs b/src/scripting/mod.rs
index 6c3c23f4..d1111ee1 100644
--- a/src/scripting/mod.rs
+++ b/src/scripting/mod.rs
@@ -1,9 +1,11 @@
pub mod bridge;
pub mod cache;
+pub mod functions;
pub mod sandbox;
pub mod types;
pub use cache::ScriptCache;
+pub use functions::FunctionRegistry;
use bytes::Bytes;
use mlua::prelude::*;
diff --git a/src/server/conn/blocking.rs b/src/server/conn/blocking.rs
index 36858ddb..950f042a 100644
--- a/src/server/conn/blocking.rs
+++ b/src/server/conn/blocking.rs
@@ -56,6 +56,30 @@ pub(crate) fn convert_blocking_to_nonblocking(cmd: &[u8], args: &[Frame]) -> Fra
for arg in args.iter().take(args.len().saturating_sub(1)) {
new_args.push(arg.clone());
}
+ } else if cmd.eq_ignore_ascii_case(b"BLMPOP") {
+ // BLMPOP timeout numkeys key [key ...] LEFT|RIGHT [COUNT n]
+ // -> LMPOP numkeys key [key ...] LEFT|RIGHT [COUNT n] (skip timeout = args[0])
+ new_args.push(Frame::BulkString(Bytes::from_static(b"LMPOP")));
+ for arg in args.iter().skip(1) {
+ new_args.push(arg.clone());
+ }
+ } else if cmd.eq_ignore_ascii_case(b"BRPOPLPUSH") {
+ // BRPOPLPUSH src dst timeout -> RPOPLPUSH src dst (skip timeout = args[2])
+ // Actually, convert to LMOVE src dst RIGHT LEFT
+ new_args.push(Frame::BulkString(Bytes::from_static(b"LMOVE")));
+ // src, dst
+ for arg in args.iter().take(2) {
+ new_args.push(arg.clone());
+ }
+ new_args.push(Frame::BulkString(Bytes::from_static(b"RIGHT")));
+ new_args.push(Frame::BulkString(Bytes::from_static(b"LEFT")));
+ } else if cmd.eq_ignore_ascii_case(b"BZMPOP") {
+ // BZMPOP timeout numkeys key [key ...] MIN|MAX [COUNT n]
+ // -> ZMPOP numkeys key [key ...] MIN|MAX [COUNT n] (skip timeout = args[0])
+ new_args.push(Frame::BulkString(Bytes::from_static(b"ZMPOP")));
+ for arg in args.iter().skip(1) {
+ new_args.push(arg.clone());
+ }
}
Frame::Array(new_args.into())
}
@@ -551,21 +575,25 @@ pub(crate) async fn handle_blocking_command_monoio(
frame
}
-/// Parse timeout from the last argument of a blocking command.
+/// Parse timeout from a blocking command.
+/// For most commands, timeout is the last argument.
+/// For BLMPOP, timeout is the first argument.
/// Returns seconds as f64. 0 = block forever.
pub(crate) fn parse_blocking_timeout(cmd: &[u8], args: &[Frame]) -> Result {
if args.is_empty() {
- return Err(Frame::Error(Bytes::from(format!(
- "ERR wrong number of arguments for '{}' command",
- String::from_utf8_lossy(cmd).to_lowercase()
- ))));
- }
- // args confirmed non-empty above — last() is guaranteed
- let Some(timeout_frame) = args.last() else {
return Err(Frame::Error(Bytes::from_static(
- b"ERR wrong number of arguments",
+ b"ERR wrong number of arguments for blocking command",
)));
- };
+ }
+ // BLMPOP/BZMPOP: timeout is the FIRST argument; others: last argument
+ let timeout_frame =
+ if cmd.eq_ignore_ascii_case(b"BLMPOP") || cmd.eq_ignore_ascii_case(b"BZMPOP") {
+ &args[0]
+ } else {
+ // args confirmed non-empty above
+ #[allow(clippy::unwrap_used)] // args.is_empty() checked at entry
+ args.last().unwrap()
+ };
let timeout_bytes = match timeout_frame {
Frame::BulkString(b) | Frame::SimpleString(b) => b,
_ => {
@@ -699,6 +727,167 @@ pub(crate) fn parse_blocking_args(
)));
}
Ok((keys, Box::new(|| crate::blocking::BlockedCommand::BZPopMax)))
+ } else if cmd.eq_ignore_ascii_case(b"BLMPOP") {
+ // BLMPOP timeout numkeys key [key ...] LEFT|RIGHT [COUNT n]
+ // args[0] = timeout (already parsed), args[1] = numkeys, args[2..2+numkeys] = keys,
+ // args[2+numkeys] = direction, optionally args[2+numkeys+1..] = COUNT n
+ if args.len() < 4 {
+ return Err(Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'blmpop' command",
+ )));
+ }
+ let numkeys_bytes = extract_bytes(&args[1])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR syntax error")))?;
+ let numkeys: usize = std::str::from_utf8(&numkeys_bytes)
+ .map_err(|_| Frame::Error(Bytes::from_static(b"ERR numkeys is not an integer")))?
+ .parse()
+ .map_err(|_| {
+ Frame::Error(Bytes::from_static(
+ b"ERR numkeys is not an integer or is out of range",
+ ))
+ })?;
+ if numkeys == 0 || args.len() < 2 + numkeys + 1 {
+ return Err(Frame::Error(Bytes::from_static(
+ b"ERR numkeys is not an integer or is out of range",
+ )));
+ }
+ let keys: Vec = args[2..2 + numkeys]
+ .iter()
+ .filter_map(|f| extract_bytes(f))
+ .collect();
+ if keys.len() != numkeys {
+ return Err(Frame::Error(Bytes::from_static(b"ERR syntax error")));
+ }
+ let dir_bytes = extract_bytes(&args[2 + numkeys])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR syntax error")))?;
+ let dir = if dir_bytes.eq_ignore_ascii_case(b"LEFT") {
+ crate::blocking::Direction::Left
+ } else if dir_bytes.eq_ignore_ascii_case(b"RIGHT") {
+ crate::blocking::Direction::Right
+ } else {
+ return Err(Frame::Error(Bytes::from_static(b"ERR syntax error")));
+ };
+ // Parse optional COUNT n
+ let mut count: u32 = 1;
+ let remaining = &args[3 + numkeys..];
+ if remaining.len() >= 2 {
+ let kw = extract_bytes(&remaining[0]);
+ if let Some(kw) = kw {
+ if kw.eq_ignore_ascii_case(b"COUNT") {
+ let count_bytes = extract_bytes(&remaining[1])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR syntax error")))?;
+ count = std::str::from_utf8(&count_bytes)
+ .map_err(|_| {
+ Frame::Error(Bytes::from_static(b"ERR count is not an integer"))
+ })?
+ .parse()
+ .map_err(|_| {
+ Frame::Error(Bytes::from_static(
+ b"ERR count is not an integer or is out of range",
+ ))
+ })?;
+ if count == 0 {
+ return Err(Frame::Error(Bytes::from_static(
+ b"ERR count is not an integer or is out of range",
+ )));
+ }
+ }
+ }
+ }
+ Ok((
+ keys,
+ Box::new(move || crate::blocking::BlockedCommand::BLMPop { dir, count }),
+ ))
+ } else if cmd.eq_ignore_ascii_case(b"BRPOPLPUSH") {
+ // BRPOPLPUSH source destination timeout
+ if args.len() != 3 {
+ return Err(Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'brpoplpush' command",
+ )));
+ }
+ let source = extract_bytes(&args[0])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR invalid source key")))?;
+ let destination = extract_bytes(&args[1])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR invalid destination key")))?;
+ Ok((
+ vec![source],
+ Box::new(move || crate::blocking::BlockedCommand::BLMove {
+ destination: destination.clone(),
+ wherefrom: crate::blocking::Direction::Right,
+ whereto: crate::blocking::Direction::Left,
+ }),
+ ))
+ } else if cmd.eq_ignore_ascii_case(b"BZMPOP") {
+ // BZMPOP timeout numkeys key [key ...] MIN|MAX [COUNT n]
+ // args[0] = timeout (already parsed), args[1] = numkeys, args[2..2+numkeys] = keys,
+ // args[2+numkeys] = MIN|MAX, optionally args[2+numkeys+1..] = COUNT n
+ if args.len() < 4 {
+ return Err(Frame::Error(Bytes::from_static(
+ b"ERR wrong number of arguments for 'bzmpop' command",
+ )));
+ }
+ let numkeys_bytes = extract_bytes(&args[1])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR syntax error")))?;
+ let numkeys: usize = std::str::from_utf8(&numkeys_bytes)
+ .map_err(|_| Frame::Error(Bytes::from_static(b"ERR numkeys is not an integer")))?
+ .parse()
+ .map_err(|_| {
+ Frame::Error(Bytes::from_static(
+ b"ERR numkeys is not an integer or is out of range",
+ ))
+ })?;
+ if numkeys == 0 || args.len() < 2 + numkeys + 1 {
+ return Err(Frame::Error(Bytes::from_static(
+ b"ERR numkeys is not an integer or is out of range",
+ )));
+ }
+ let keys: Vec = args[2..2 + numkeys]
+ .iter()
+ .filter_map(|f| extract_bytes(f))
+ .collect();
+ if keys.len() != numkeys {
+ return Err(Frame::Error(Bytes::from_static(b"ERR syntax error")));
+ }
+ let side_bytes = extract_bytes(&args[2 + numkeys])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR syntax error")))?;
+ let is_min = if side_bytes.eq_ignore_ascii_case(b"MIN") {
+ true
+ } else if side_bytes.eq_ignore_ascii_case(b"MAX") {
+ false
+ } else {
+ return Err(Frame::Error(Bytes::from_static(b"ERR syntax error")));
+ };
+ // Parse optional COUNT n
+ let mut count: u32 = 1;
+ let remaining = &args[3 + numkeys..];
+ if remaining.len() >= 2 {
+ let kw = extract_bytes(&remaining[0]);
+ if let Some(kw) = kw {
+ if kw.eq_ignore_ascii_case(b"COUNT") {
+ let count_bytes = extract_bytes(&remaining[1])
+ .ok_or_else(|| Frame::Error(Bytes::from_static(b"ERR syntax error")))?;
+ count = std::str::from_utf8(&count_bytes)
+ .map_err(|_| {
+ Frame::Error(Bytes::from_static(b"ERR count is not an integer"))
+ })?
+ .parse()
+ .map_err(|_| {
+ Frame::Error(Bytes::from_static(
+ b"ERR count is not an integer or is out of range",
+ ))
+ })?;
+ if count == 0 {
+ return Err(Frame::Error(Bytes::from_static(
+ b"ERR count is not an integer or is out of range",
+ )));
+ }
+ }
+ }
+ }
+ Ok((
+ keys,
+ Box::new(move || crate::blocking::BlockedCommand::BZMPop { min: is_min, count }),
+ ))
} else {
Err(Frame::Error(Bytes::from_static(
b"ERR unknown blocking command",
@@ -767,6 +956,132 @@ pub(crate) fn try_immediate_pop(
Direction::Right => db.list_push_back(&dest, val.clone()),
}
Some(Frame::BulkString(val))
+ } else if cmd.eq_ignore_ascii_case(b"BLMPOP") {
+ // BLMPOP: immediate pop up to COUNT elements
+ // args: [timeout, numkeys, key [key ...], LEFT|RIGHT, [COUNT n]]
+ let numkeys_bytes = extract_bytes(&args[1])?;
+ let numkeys: usize = std::str::from_utf8(&numkeys_bytes).ok()?.parse().ok()?;
+ if numkeys == 0 || args.len() < 2 + numkeys + 1 {
+ return None;
+ }
+ let dir_bytes = extract_bytes(&args[2 + numkeys])?;
+ let dir = if dir_bytes.eq_ignore_ascii_case(b"LEFT") {
+ crate::blocking::Direction::Left
+ } else {
+ crate::blocking::Direction::Right
+ };
+ // Parse COUNT
+ let mut count: u32 = 1;
+ let remaining = &args[3 + numkeys..];
+ if remaining.len() >= 2 {
+ if let Some(kw) = extract_bytes(&remaining[0]) {
+ if kw.eq_ignore_ascii_case(b"COUNT") {
+ if let Some(cb) = extract_bytes(&remaining[1]) {
+ if let Some(c) = std::str::from_utf8(&cb)
+ .ok()
+ .and_then(|s| s.parse::().ok())
+ {
+ if c > 0 {
+ count = c;
+ }
+ }
+ }
+ }
+ }
+ }
+ // Check if list has elements
+ let list_len = match db.get_list(key) {
+ Ok(Some(l)) => l.len(),
+ _ => 0,
+ };
+ if list_len == 0 {
+ return None;
+ }
+ let n = std::cmp::min(count as usize, list_len);
+ let mut elems = smallvec::SmallVec::<[Frame; 16]>::new();
+ for _ in 0..n {
+ let val = match dir {
+ crate::blocking::Direction::Left => db.list_pop_front(key),
+ crate::blocking::Direction::Right => db.list_pop_back(key),
+ };
+ match val {
+ Some(v) => elems.push(Frame::BulkString(v)),
+ None => break,
+ }
+ }
+ if elems.is_empty() {
+ None
+ } else {
+ let elem_vec: Vec = elems.into_vec();
+ Some(Frame::Array(framevec![
+ Frame::BulkString(key.clone()),
+ Frame::Array(elem_vec.into()),
+ ]))
+ }
+ } else if cmd.eq_ignore_ascii_case(b"BRPOPLPUSH") {
+ // BRPOPLPUSH: immediate RPOP from source, LPUSH to destination
+ // args: [source, destination, timeout]
+ let dest = extract_bytes(&args[1])?;
+ let val = db.list_pop_back(key)?;
+ db.list_push_front(&dest, val.clone());
+ Some(Frame::BulkString(val))
+ } else if cmd.eq_ignore_ascii_case(b"BZMPOP") {
+ // BZMPOP: immediate pop from sorted set
+ // args: [timeout, numkeys, key [key ...], MIN|MAX, [COUNT n]]
+ let numkeys_bytes = extract_bytes(&args[1])?;
+ let numkeys: usize = std::str::from_utf8(&numkeys_bytes).ok()?.parse().ok()?;
+ if numkeys == 0 || args.len() < 2 + numkeys + 1 {
+ return None;
+ }
+ let side_bytes = extract_bytes(&args[2 + numkeys])?;
+ let is_min = side_bytes.eq_ignore_ascii_case(b"MIN");
+ // Parse COUNT
+ let mut count: u32 = 1;
+ let remaining = &args[3 + numkeys..];
+ if remaining.len() >= 2 {
+ if let Some(kw) = extract_bytes(&remaining[0]) {
+ if kw.eq_ignore_ascii_case(b"COUNT") {
+ if let Some(cb) = extract_bytes(&remaining[1]) {
+ if let Some(c) = std::str::from_utf8(&cb)
+ .ok()
+ .and_then(|s| s.parse::().ok())
+ {
+ if c > 0 {
+ count = c;
+ }
+ }
+ }
+ }
+ }
+ }
+ // Check if sorted set has elements (use zset_pop to check)
+ let n = count as usize;
+ let mut elems = smallvec::SmallVec::<[Frame; 16]>::new();
+ for _ in 0..n {
+ let popped = if is_min {
+ db.zset_pop_min(key)
+ } else {
+ db.zset_pop_max(key)
+ };
+ match popped {
+ Some((member, score)) => {
+ elems.push(Frame::Array(framevec![
+ Frame::BulkString(member),
+ Frame::BulkString(Bytes::from(format_blocking_score(score))),
+ ]));
+ }
+ None => break,
+ }
+ }
+ if elems.is_empty() {
+ None
+ } else {
+ let elem_vec: Vec = elems.into_vec();
+ Some(Frame::Array(framevec![
+ Frame::BulkString(key.clone()),
+ Frame::Array(elem_vec.into()),
+ ]))
+ }
} else {
None
}
diff --git a/src/server/conn/handler_monoio.rs b/src/server/conn/handler_monoio.rs
index 7a3e331d..495c855a 100644
--- a/src/server/conn/handler_monoio.rs
+++ b/src/server/conn/handler_monoio.rs
@@ -150,6 +150,9 @@ pub async fn handle_connection_sharded_monoio<
let mut pubsub_tx: Option> = None;
let mut pubsub_rx: Option> = None;
+ // Functions API registry (per-connection, lazy init)
+ let func_registry = Rc::new(RefCell::new(crate::scripting::FunctionRegistry::new()));
+
// Transaction (MULTI/EXEC) connection-local state
let mut in_multi: bool = false;
let mut command_queue: Vec = Vec::new();
@@ -1273,6 +1276,54 @@ pub async fn handle_connection_sharded_monoio<
}
}
+ // --- Functions API: FUNCTION/FCALL/FCALL_RO ---
+ // Placed AFTER ACL check. Respects MULTI queue — if in_multi,
+ // fall through to the MULTI queue gate instead of executing.
+ if !in_multi {
+ if cmd.eq_ignore_ascii_case(b"FUNCTION") {
+ let response = crate::command::functions::handle_function(
+ &mut func_registry.borrow_mut(),
+ cmd_args,
+ );
+ responses.push(response);
+ continue;
+ }
+ if cmd.eq_ignore_ascii_case(b"FCALL") {
+ let response = {
+ let mut guard = shard_databases.write_db(shard_id, selected_db);
+ let db_count = shard_databases.db_count();
+ crate::command::functions::handle_fcall(
+ &func_registry.borrow(),
+ cmd_args,
+ &mut guard,
+ shard_id,
+ num_shards,
+ selected_db,
+ db_count,
+ )
+ };
+ responses.push(response);
+ continue;
+ }
+ if cmd.eq_ignore_ascii_case(b"FCALL_RO") {
+ let response = {
+ let mut guard = shard_databases.write_db(shard_id, selected_db);
+ let db_count = shard_databases.db_count();
+ crate::command::functions::handle_fcall_ro(
+ &func_registry.borrow(),
+ cmd_args,
+ &mut guard,
+ shard_id,
+ num_shards,
+ selected_db,
+ db_count,
+ )
+ };
+ responses.push(response);
+ continue;
+ }
+ }
+
// --- MULTI ---
if cmd.eq_ignore_ascii_case(b"MULTI") {
if in_multi {
@@ -1320,12 +1371,15 @@ pub async fn handle_connection_sharded_monoio<
continue;
}
- // --- BLOCKING COMMANDS (BLPOP, BRPOP, BLMOVE, BZPOPMIN, BZPOPMAX) ---
+ // --- BLOCKING COMMANDS ---
if cmd.eq_ignore_ascii_case(b"BLPOP")
|| cmd.eq_ignore_ascii_case(b"BRPOP")
|| cmd.eq_ignore_ascii_case(b"BLMOVE")
|| cmd.eq_ignore_ascii_case(b"BZPOPMIN")
|| cmd.eq_ignore_ascii_case(b"BZPOPMAX")
+ || cmd.eq_ignore_ascii_case(b"BLMPOP")
+ || cmd.eq_ignore_ascii_case(b"BRPOPLPUSH")
+ || cmd.eq_ignore_ascii_case(b"BZMPOP")
{
// Inside MULTI: queue as non-blocking variant
if in_multi {
diff --git a/src/server/conn/handler_sharded.rs b/src/server/conn/handler_sharded.rs
index 0f863510..57a2adbb 100644
--- a/src/server/conn/handler_sharded.rs
+++ b/src/server/conn/handler_sharded.rs
@@ -302,6 +302,11 @@ pub async fn handle_connection_sharded_inner<
let acl_max_len = runtime_config.read().acllog_max_len;
let mut acl_log = crate::acl::AclLog::new(acl_max_len);
+ // Functions API registry (per-shard, lazy init)
+ let func_registry = std::rc::Rc::new(std::cell::RefCell::new(
+ crate::scripting::FunctionRegistry::new(),
+ ));
+
// Transaction (MULTI/EXEC) connection-local state
let mut in_multi: bool = false;
let mut command_queue: Vec = Vec::new();
@@ -824,6 +829,43 @@ pub async fn handle_connection_sharded_inner<
}
}
+ // --- Functions API: FUNCTION/FCALL/FCALL_RO ---
+ // Placed AFTER ACL check. Respects MULTI queue — if in_multi,
+ // fall through to the MULTI queue gate instead of executing.
+ if !in_multi {
+ if cmd.eq_ignore_ascii_case(b"FUNCTION") {
+ let response = crate::command::functions::handle_function(
+ &mut func_registry.borrow_mut(), cmd_args,
+ );
+ responses.push(response);
+ continue;
+ }
+ if cmd.eq_ignore_ascii_case(b"FCALL") {
+ let response = {
+ let mut guard = shard_databases.write_db(shard_id, selected_db);
+ let db_count = shard_databases.db_count();
+ crate::command::functions::handle_fcall(
+ &func_registry.borrow(), cmd_args, &mut guard,
+ shard_id, num_shards, selected_db, db_count,
+ )
+ };
+ responses.push(response);
+ continue;
+ }
+ if cmd.eq_ignore_ascii_case(b"FCALL_RO") {
+ let response = {
+ let mut guard = shard_databases.write_db(shard_id, selected_db);
+ let db_count = shard_databases.db_count();
+ crate::command::functions::handle_fcall_ro(
+ &func_registry.borrow(), cmd_args, &mut guard,
+ shard_id, num_shards, selected_db, db_count,
+ )
+ };
+ responses.push(response);
+ continue;
+ }
+ }
+
// --- CONFIG ---
if cmd.eq_ignore_ascii_case(b"CONFIG") {
responses.push(handle_config(cmd_args, &runtime_config, &config));
@@ -1031,6 +1073,8 @@ pub async fn handle_connection_sharded_inner<
if cmd.eq_ignore_ascii_case(b"BLPOP") || cmd.eq_ignore_ascii_case(b"BRPOP")
|| cmd.eq_ignore_ascii_case(b"BLMOVE") || cmd.eq_ignore_ascii_case(b"BZPOPMIN")
|| cmd.eq_ignore_ascii_case(b"BZPOPMAX")
+ || cmd.eq_ignore_ascii_case(b"BLMPOP") || cmd.eq_ignore_ascii_case(b"BRPOPLPUSH")
+ || cmd.eq_ignore_ascii_case(b"BZMPOP")
{
if in_multi {
let nb_frame = convert_blocking_to_nonblocking(cmd, cmd_args);
diff --git a/src/server/conn_state.rs b/src/server/conn_state.rs
index 18e248d7..4e112b9d 100644
--- a/src/server/conn_state.rs
+++ b/src/server/conn_state.rs
@@ -43,6 +43,7 @@ pub struct ConnectionContext {
pub cluster_state: Option>>,
pub lua: Rc,
pub script_cache: Rc>,
+ pub func_registry: Rc>,
pub config_port: u16,
pub acl_table: Arc>,
pub runtime_config: Arc>,
diff --git a/src/storage/hll.rs b/src/storage/hll.rs
new file mode 100644
index 00000000..8d38c8b0
--- /dev/null
+++ b/src/storage/hll.rs
@@ -0,0 +1,1020 @@
+//! HyperLogLog implementation — byte-identical with Redis 7.x HYLL format.
+//!
+//! Uses MurmurHash64A with seed 0xadc83b19 and the Ertl improved estimator
+//! (hll_sigma/hll_tau) instead of bias correction tables.
+//!
+//! Storage: `RedisValue::String(Bytes)` — the raw HYLL wire bytes.
+//! Redis `TYPE` reports "string" for HLL keys; GET/SET/DUMP/RESTORE work.
+
+use bytes::{BufMut, Bytes, BytesMut};
+
+// ---------------------------------------------------------------------------
+// Constants (match Redis hyperloglog.c exactly)
+// ---------------------------------------------------------------------------
+
+pub const HLL_P: u32 = 14;
+pub const HLL_Q: u32 = 64 - HLL_P; // 50
+pub const HLL_REGISTERS: usize = 1 << HLL_P; // 16384
+const HLL_P_MASK: u64 = (HLL_REGISTERS as u64) - 1;
+pub const HLL_BITS: u32 = 6;
+pub const HLL_REGISTER_MAX: u8 = (1 << HLL_BITS) - 1; // 63
+pub const HLL_HDR_SIZE: usize = 16;
+pub const HLL_DENSE_SIZE: usize = HLL_HDR_SIZE + ((HLL_REGISTERS * HLL_BITS as usize + 7) / 8); // 12304
+pub const HLL_DENSE: u8 = 0;
+pub const HLL_SPARSE: u8 = 1;
+const HLL_MAX_ENCODING: u8 = 1;
+const HLL_ALPHA_INF: f64 = 0.721_347_520_444_481_7;
+
+// Sparse opcode constants
+const HLL_SPARSE_VAL_MAX_VALUE: u8 = 32;
+const HLL_SPARSE_MAX_BYTES: usize = 3000;
+
+pub const HLL_HASH_SEED: u64 = 0xadc83b19;
+
+const HLL_MAGIC: &[u8; 4] = b"HYLL";
+
+// ---------------------------------------------------------------------------
+// MurmurHash64A — safe Rust port (no unsafe)
+// ---------------------------------------------------------------------------
+
+/// MurmurHash64A hash function, safe Rust port.
+/// Redis HLL uses seed 0xadc83b19 (HLL_HASH_SEED).
+pub fn murmurhash64a(key: &[u8], seed: u64) -> u64 {
+ const M: u64 = 0xc6a4a7935bd1e995;
+ const R: u32 = 47;
+
+ let len = key.len();
+ let mut h: u64 = seed ^ ((len as u64).wrapping_mul(M));
+
+ // Process 8-byte chunks
+ let chunks = len / 8;
+ for i in 0..chunks {
+ // Loop invariant: i < chunks where chunks = len / 8, so i*8+8 <= len.
+ #[allow(clippy::unwrap_used)]
+ let mut k = u64::from_le_bytes(key[i * 8..i * 8 + 8].try_into().unwrap());
+ k = k.wrapping_mul(M);
+ k ^= k >> R;
+ k = k.wrapping_mul(M);
+ h ^= k;
+ h = h.wrapping_mul(M);
+ }
+
+ // Process remaining bytes (fallthrough pattern matching Redis exactly)
+ let remaining = &key[chunks * 8..];
+ let rlen = remaining.len();
+ if rlen >= 7 {
+ h ^= (remaining[6] as u64) << 48;
+ }
+ if rlen >= 6 {
+ h ^= (remaining[5] as u64) << 40;
+ }
+ if rlen >= 5 {
+ h ^= (remaining[4] as u64) << 32;
+ }
+ if rlen >= 4 {
+ h ^= (remaining[3] as u64) << 24;
+ }
+ if rlen >= 3 {
+ h ^= (remaining[2] as u64) << 16;
+ }
+ if rlen >= 2 {
+ h ^= (remaining[1] as u64) << 8;
+ }
+ if rlen >= 1 {
+ h ^= remaining[0] as u64;
+ h = h.wrapping_mul(M);
+ }
+
+ h ^= h >> R;
+ h = h.wrapping_mul(M);
+ h ^= h >> R;
+ h
+}
+
+// ---------------------------------------------------------------------------
+// Dense register accessors — pure shifts/masks, no unsafe
+// ---------------------------------------------------------------------------
+
+/// Get 6-bit register value at index `reg` from dense payload buffer.
+#[inline]
+fn dense_get(registers: &[u8], reg: usize) -> u8 {
+ let bit_offset = reg * HLL_BITS as usize;
+ let byte_offset = bit_offset / 8;
+ let fb = bit_offset & 7;
+
+ let b0 = registers[byte_offset] as u16;
+ let b1 = if byte_offset + 1 < registers.len() {
+ registers[byte_offset + 1] as u16
+ } else {
+ 0
+ };
+ ((b0 >> fb) | (b1 << (8 - fb))) as u8 & 0x3F
+}
+
+/// Set 6-bit register value at index `reg` in dense payload buffer.
+#[inline]
+fn dense_set(registers: &mut [u8], reg: usize, val: u8) {
+ let bit_offset = reg * HLL_BITS as usize;
+ let byte_offset = bit_offset / 8;
+ let fb = bit_offset & 7;
+
+ let mask = 0x3F_u16;
+ let b0 = registers[byte_offset] as u16;
+ let b1 = if byte_offset + 1 < registers.len() {
+ registers[byte_offset + 1] as u16
+ } else {
+ 0
+ };
+
+ let cleared0 = b0 & !(mask << fb);
+ let cleared1 = b1 & !((mask >> (8 - fb)) & 0xFF);
+
+ registers[byte_offset] = (cleared0 | ((val as u16) << fb)) as u8;
+ if byte_offset + 1 < registers.len() {
+ registers[byte_offset + 1] = (cleared1 | ((val as u16) >> (8 - fb))) as u8;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Ertl improved estimator (replaces bias tables)
+// ---------------------------------------------------------------------------
+
+fn hll_sigma(x: f64) -> f64 {
+ if x == 1.0 {
+ return f64::INFINITY;
+ }
+ let mut x = x;
+ let mut z_prime: f64;
+ let mut y: f64 = 1.0;
+ let mut z: f64 = x;
+ loop {
+ x *= x;
+ z_prime = z;
+ z += x * y;
+ y += y;
+ if z_prime == z {
+ break;
+ }
+ }
+ z
+}
+
+fn hll_tau(x: f64) -> f64 {
+ if x == 0.0 || x == 1.0 {
+ return 0.0;
+ }
+ let mut x = x;
+ let mut z_prime: f64;
+ let mut y: f64 = 1.0;
+ let mut z: f64 = 1.0 - x;
+ loop {
+ x = x.sqrt();
+ z_prime = z;
+ y *= 0.5;
+ z -= (1.0 - x).powi(2) * y;
+ if z_prime == z {
+ break;
+ }
+ }
+ z / 3.0
+}
+
+/// Compute cardinality from register histogram.
+/// `reghisto[i]` = count of registers with value i (0..=HLL_Q+1).
+fn hll_count(reghisto: &[u32; 64]) -> u64 {
+ let m = HLL_REGISTERS as f64;
+
+ let mut z = m * hll_tau((m - reghisto[HLL_Q as usize + 1] as f64) / m);
+ for j in (1..=HLL_Q as usize).rev() {
+ z += reghisto[j] as f64;
+ z *= 0.5;
+ }
+ z += m * hll_sigma(reghisto[0] as f64 / m);
+ (HLL_ALPHA_INF * m * m / z).round() as u64
+}
+
+// ---------------------------------------------------------------------------
+// Sparse opcode helpers
+// ---------------------------------------------------------------------------
+
+/// Decoded sparse opcode.
+#[derive(Debug, Clone, Copy)]
+enum SparseOp {
+ Zero(u16), // run of zeros, length 1..64
+ XZero(u16), // run of zeros, length 1..16384
+ Val(u8, u16), // run of val (1..32), length 1..4
+}
+
+impl SparseOp {
+ /// Number of registers covered by this opcode.
+ fn span(&self) -> u16 {
+ match *self {
+ SparseOp::Zero(n) => n,
+ SparseOp::XZero(n) => n,
+ SparseOp::Val(_, n) => n,
+ }
+ }
+
+ /// Register value (0 for ZERO/XZERO opcodes).
+ fn value(&self) -> u8 {
+ match *self {
+ SparseOp::Zero(_) | SparseOp::XZero(_) => 0,
+ SparseOp::Val(v, _) => v,
+ }
+ }
+}
+
+/// Decode one sparse opcode at `data[pos..]`. Returns `Some((op, bytes_consumed))`
+/// or `None` if `pos` is out of bounds or the opcode is truncated.
+fn sparse_decode(data: &[u8], pos: usize) -> Option<(SparseOp, usize)> {
+ if pos >= data.len() {
+ return None;
+ }
+ let b = data[pos];
+ if b & 0x80 != 0 {
+ // VAL: 1vvvvvxx
+ let val = ((b >> 2) & 0x1F) + 1;
+ let runlen = (b & 0x03) as u16 + 1;
+ Some((SparseOp::Val(val, runlen), 1))
+ } else if b & 0x40 != 0 {
+ // XZERO: 01xxxxxx yyyyyyyy (2 bytes)
+ if pos + 1 >= data.len() {
+ return None;
+ }
+ let runlen = (((b & 0x3F) as u16) << 8 | data[pos + 1] as u16) + 1;
+ Some((SparseOp::XZero(runlen), 2))
+ } else {
+ // ZERO: 00xxxxxx
+ let runlen = (b & 0x3F) as u16 + 1;
+ Some((SparseOp::Zero(runlen), 1))
+ }
+}
+
+/// Encode a ZERO opcode (run of zeros, length 1..64).
+fn sparse_encode_zero(len: u16) -> u8 {
+ debug_assert!(len >= 1 && len <= 64);
+ (len - 1) as u8
+}
+
+/// Encode an XZERO opcode (run of zeros, length 1..16384). Returns 2 bytes.
+fn sparse_encode_xzero(len: u16) -> [u8; 2] {
+ debug_assert!(len >= 1 && len <= 16384);
+ let v = len - 1;
+ [0x40 | ((v >> 8) as u8), (v & 0xFF) as u8]
+}
+
+/// Encode a VAL opcode (run of val, length 1..4, value 1..32).
+fn sparse_encode_val(val: u8, len: u16) -> u8 {
+ debug_assert!(val >= 1 && val <= 32);
+ debug_assert!(len >= 1 && len <= 4);
+ 0x80 | ((val - 1) << 2) | (len - 1) as u8
+}
+
+/// Emit zero-run opcodes into `out` covering `len` registers.
+fn emit_zeros(out: &mut BytesMut, mut len: u16) {
+ while len > 0 {
+ if len > 64 {
+ let chunk = len.min(16384);
+ let xz = sparse_encode_xzero(chunk);
+ out.put_slice(&xz);
+ len -= chunk;
+ } else {
+ out.put_u8(sparse_encode_zero(len));
+ len = 0;
+ }
+ }
+}
+
+/// Emit val-run opcodes into `out` covering `len` registers with `val`.
+fn emit_vals(out: &mut BytesMut, val: u8, mut len: u16) {
+ while len > 0 {
+ let chunk = len.min(4);
+ out.put_u8(sparse_encode_val(val, chunk));
+ len -= chunk;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Error type
+// ---------------------------------------------------------------------------
+
+/// Errors when parsing or operating on HLL data.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum HllError {
+ BadMagic,
+ BadEncoding,
+ Truncated,
+ InvalidSparseOpcode,
+}
+
+// ---------------------------------------------------------------------------
+// Hll struct
+// ---------------------------------------------------------------------------
+
+/// HyperLogLog data structure with byte-identical Redis 7.x HYLL wire format.
+#[derive(Debug)]
+pub struct Hll {
+ buf: BytesMut,
+}
+
+impl Hll {
+ /// Create a new sparse HLL (starts as a single XZERO(16384) opcode).
+ pub fn new_sparse() -> Self {
+ let mut buf = BytesMut::with_capacity(HLL_HDR_SIZE + 2);
+ buf.put_slice(HLL_MAGIC);
+ buf.put_u8(HLL_SPARSE);
+ buf.put_bytes(0, 3);
+ let invalid_card: u64 = 1u64 << 63;
+ buf.put_u64_le(invalid_card);
+ // XZERO(16384): 01_111111 11111111
+ buf.put_u8(0x7F);
+ buf.put_u8(0xFF);
+ Hll { buf }
+ }
+
+ /// Create a new dense HLL (all registers zeroed).
+ fn new_dense() -> Self {
+ let mut buf = BytesMut::with_capacity(HLL_DENSE_SIZE);
+ buf.put_slice(HLL_MAGIC);
+ buf.put_u8(HLL_DENSE);
+ buf.put_bytes(0, 3);
+ let invalid_card: u64 = 1u64 << 63;
+ buf.put_u64_le(invalid_card);
+ buf.put_bytes(0, HLL_DENSE_SIZE - HLL_HDR_SIZE);
+ Hll { buf }
+ }
+
+ /// Construct from existing HYLL bytes (validates header).
+ pub fn from_bytes(bytes: Bytes) -> Result {
+ if bytes.len() < HLL_HDR_SIZE {
+ return Err(HllError::Truncated);
+ }
+ if &bytes[0..4] != HLL_MAGIC {
+ return Err(HllError::BadMagic);
+ }
+ let encoding = bytes[4];
+ if encoding > HLL_MAX_ENCODING {
+ return Err(HllError::BadEncoding);
+ }
+ if encoding == HLL_DENSE && bytes.len() < HLL_DENSE_SIZE {
+ return Err(HllError::Truncated);
+ }
+ Ok(Hll {
+ buf: BytesMut::from(bytes.as_ref()),
+ })
+ }
+
+ /// Consume self and return the wire bytes.
+ pub fn into_bytes(self) -> Bytes {
+ self.buf.freeze()
+ }
+
+ /// Borrow the wire bytes.
+ pub fn as_bytes(&self) -> &[u8] {
+ &self.buf
+ }
+
+ /// Check if a byte slice starts with the HYLL magic.
+ pub fn is_hll(bytes: &[u8]) -> bool {
+ bytes.len() >= HLL_HDR_SIZE && &bytes[0..4] == HLL_MAGIC
+ }
+
+ /// Returns true if this HLL uses sparse encoding.
+ pub fn is_sparse(&self) -> bool {
+ self.buf[4] == HLL_SPARSE
+ }
+
+ /// Returns true if this HLL uses dense encoding.
+ pub fn is_dense(&self) -> bool {
+ self.buf[4] == HLL_DENSE
+ }
+
+ // -- Cache management --
+
+ fn cache_valid(&self) -> bool {
+ self.buf[15] & 0x80 == 0
+ }
+
+ fn cached_card(&self) -> u64 {
+ // from_bytes() validates buf.len() >= 16 (HLL_HDR_SIZE); new_sparse/new_dense guarantee it.
+ #[allow(clippy::unwrap_used)]
+ let raw = u64::from_le_bytes(self.buf[8..16].try_into().unwrap());
+ raw & !(1u64 << 63)
+ }
+
+ fn set_cached_card(&mut self, card: u64) {
+ let bytes = card.to_le_bytes();
+ self.buf[8..16].copy_from_slice(&bytes);
+ self.buf[15] &= 0x7F;
+ }
+
+ fn invalidate_cache(&mut self) {
+ self.buf[15] |= 0x80;
+ }
+
+ // -- Dense register helpers --
+
+ fn dense_registers(&self) -> &[u8] {
+ &self.buf[HLL_HDR_SIZE..]
+ }
+
+ fn dense_registers_mut(&mut self) -> &mut [u8] {
+ &mut self.buf[HLL_HDR_SIZE..]
+ }
+
+ fn get_register_dense(&self, reg: usize) -> u8 {
+ dense_get(self.dense_registers(), reg)
+ }
+
+ fn set_register_dense(&mut self, reg: usize, val: u8) {
+ dense_set(self.dense_registers_mut(), reg, val);
+ }
+
+ // -- Sparse payload --
+
+ fn sparse_payload(&self) -> &[u8] {
+ &self.buf[HLL_HDR_SIZE..]
+ }
+
+ // -- Promote sparse to dense --
+
+ fn promote_to_dense(&mut self) {
+ let mut dense = Hll::new_dense();
+ // Walk sparse opcodes, write to dense
+ let payload = &self.buf[HLL_HDR_SIZE..];
+ let mut pos = 0;
+ let mut reg_idx = 0usize;
+ while pos < payload.len() {
+ let Some((op, consumed)) = sparse_decode(payload, pos) else {
+ break;
+ };
+ pos += consumed;
+ match op {
+ SparseOp::Zero(n) | SparseOp::XZero(n) => {
+ reg_idx += n as usize; // zeros, already 0 in dense
+ }
+ SparseOp::Val(v, n) => {
+ for _ in 0..n {
+ dense.set_register_dense(reg_idx, v);
+ reg_idx += 1;
+ }
+ }
+ }
+ }
+ // Copy invalid cache from sparse header
+ dense.invalidate_cache();
+ self.buf = dense.buf;
+ }
+
+ // -- Core operations --
+
+ /// Hash element, compute register index and count.
+ fn hash_element(element: &[u8]) -> (usize, u8) {
+ let hash = murmurhash64a(element, HLL_HASH_SEED);
+ let index = (hash & HLL_P_MASK) as usize;
+ // Upper bits + sentinel: ensures trailing_zeros is bounded by HLL_Q
+ let bits = (hash >> HLL_P) | (1u64 << HLL_Q);
+ let count = (bits.trailing_zeros() + 1) as u8;
+ (index, count)
+ }
+
+ /// Add an element. Returns true if any register changed.
+ pub fn add(&mut self, element: &[u8]) -> bool {
+ let (index, count) = Self::hash_element(element);
+
+ if self.is_dense() {
+ return self.add_dense(index, count);
+ }
+ // Sparse path
+ self.add_sparse(index, count)
+ }
+
+ /// Dense add: update register if count > current.
+ fn add_dense(&mut self, index: usize, count: u8) -> bool {
+ let old = self.get_register_dense(index);
+ if count > old {
+ self.set_register_dense(index, count);
+ self.invalidate_cache();
+ return true;
+ }
+ false
+ }
+
+ /// Sparse add: find the opcode covering `index`, update or promote.
+ fn add_sparse(&mut self, index: usize, count: u8) -> bool {
+ // Value too large for sparse encoding? Promote.
+ if count > HLL_SPARSE_VAL_MAX_VALUE {
+ self.promote_to_dense();
+ return self.add_dense(index, count);
+ }
+
+ let payload = &self.buf[HLL_HDR_SIZE..];
+ let payload_len = payload.len();
+
+ // Find the opcode covering `index`
+ let mut pos = 0;
+ let mut reg_pos = 0usize;
+ let mut found_pos = 0;
+ let mut found_op = SparseOp::Zero(0);
+ let mut found_consumed = 0;
+ let mut found_reg_start = 0;
+
+ while pos < payload_len {
+ let Some((op, consumed)) = sparse_decode(payload, pos) else {
+ break;
+ };
+ let span = op.span() as usize;
+ if reg_pos + span > index {
+ found_pos = pos;
+ found_op = op;
+ found_consumed = consumed;
+ found_reg_start = reg_pos;
+ break;
+ }
+ reg_pos += span;
+ pos += consumed;
+ }
+
+ let current_val = found_op.value();
+ if count <= current_val {
+ return false; // no change
+ }
+
+ // Build replacement opcodes
+ let offset_in_run = index - found_reg_start;
+ let span = found_op.span() as usize;
+ let mut replacement = BytesMut::with_capacity(16);
+
+ // Emit: zeros_before + val_run_before + new_val + val_run_after + zeros_after
+ // But we need to handle: the opcode might be a ZERO/XZERO (val=0) or VAL
+ match found_op {
+ SparseOp::Zero(_) | SparseOp::XZero(_) => {
+ // Before the target: emit zeros
+ if offset_in_run > 0 {
+ emit_zeros(&mut replacement, offset_in_run as u16);
+ }
+ // The target register
+ replacement.put_u8(sparse_encode_val(count, 1));
+ // After the target: emit zeros
+ let after = span - offset_in_run - 1;
+ if after > 0 {
+ emit_zeros(&mut replacement, after as u16);
+ }
+ }
+ SparseOp::Val(old_val, _run_len) => {
+ // Before: run of old_val
+ if offset_in_run > 0 {
+ emit_vals(&mut replacement, old_val, offset_in_run as u16);
+ }
+ // The target register with new value
+ replacement.put_u8(sparse_encode_val(count, 1));
+ // After: run of old_val
+ let after = span - offset_in_run - 1;
+ if after > 0 {
+ emit_vals(&mut replacement, old_val, after as u16);
+ }
+ }
+ }
+
+ // Check if resulting sparse payload would exceed max size
+ let new_payload_len = payload_len - found_consumed + replacement.len();
+ if new_payload_len > HLL_SPARSE_MAX_BYTES {
+ self.promote_to_dense();
+ return self.add_dense(index, count);
+ }
+
+ // Splice: replace the bytes at [found_pos..found_pos+found_consumed]
+ // with `replacement`
+ let header_end = HLL_HDR_SIZE;
+ let splice_start = header_end + found_pos;
+ let splice_end = splice_start + found_consumed;
+
+ let mut new_buf = BytesMut::with_capacity(header_end + new_payload_len);
+ new_buf.put_slice(&self.buf[..splice_start]);
+ new_buf.put_slice(&replacement);
+ new_buf.put_slice(&self.buf[splice_end..]);
+ self.buf = new_buf;
+ self.invalidate_cache();
+ true
+ }
+
+ /// Build register histogram from dense encoding.
+ fn dense_reghisto(&self) -> [u32; 64] {
+ let mut reghisto = [0u32; 64];
+ let regs = self.dense_registers();
+ for i in 0..HLL_REGISTERS {
+ let val = dense_get(regs, i) as usize;
+ reghisto[val] += 1;
+ }
+ reghisto
+ }
+
+ /// Build register histogram from sparse encoding.
+ fn sparse_reghisto(&self) -> [u32; 64] {
+ let mut reghisto = [0u32; 64];
+ let payload = self.sparse_payload();
+ let mut pos = 0;
+ while pos < payload.len() {
+ let Some((op, consumed)) = sparse_decode(payload, pos) else {
+ break;
+ };
+ pos += consumed;
+ match op {
+ SparseOp::Zero(n) | SparseOp::XZero(n) => {
+ reghisto[0] += n as u32;
+ }
+ SparseOp::Val(v, n) => {
+ reghisto[v as usize] += n as u32;
+ }
+ }
+ }
+ reghisto
+ }
+
+ /// Return the cardinality estimate (read-only, uses cache if valid).
+ pub fn count(&self) -> u64 {
+ if self.cache_valid() {
+ return self.cached_card();
+ }
+ let reghisto = if self.is_dense() {
+ self.dense_reghisto()
+ } else {
+ self.sparse_reghisto()
+ };
+ hll_count(®histo)
+ }
+
+ /// Return the cardinality estimate and cache the result.
+ pub fn count_and_cache(&mut self) -> u64 {
+ if self.cache_valid() {
+ return self.cached_card();
+ }
+ let reghisto = if self.is_dense() {
+ self.dense_reghisto()
+ } else {
+ self.sparse_reghisto()
+ };
+ let card = hll_count(®histo);
+ self.set_cached_card(card);
+ card
+ }
+
+ /// Iterate all registers of this HLL, calling `f(register_index, value)`.
+ fn for_each_register(&self, mut f: F) {
+ if self.is_dense() {
+ let regs = self.dense_registers();
+ for i in 0..HLL_REGISTERS {
+ f(i, dense_get(regs, i));
+ }
+ } else {
+ let payload = self.sparse_payload();
+ let mut pos = 0;
+ let mut reg_idx = 0;
+ while pos < payload.len() {
+ let Some((op, consumed)) = sparse_decode(payload, pos) else {
+ break;
+ };
+ pos += consumed;
+ let span = op.span() as usize;
+ let val = op.value();
+ for _ in 0..span {
+ f(reg_idx, val);
+ reg_idx += 1;
+ }
+ }
+ }
+ }
+
+ /// Merge another HLL into self (register-max).
+ /// Promotes self to dense if needed.
+ pub fn merge_from(&mut self, other: &Hll) {
+ // Promote self to dense for merge (Redis does this too)
+ if self.is_sparse() {
+ self.promote_to_dense();
+ }
+ // Take register-max from other
+ other.for_each_register(|i, val| {
+ if val > 0 {
+ let cur = self.get_register_dense(i);
+ if val > cur {
+ self.set_register_dense(i, val);
+ }
+ }
+ });
+ self.invalidate_cache();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Unit tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn murmur_empty_string_kat() {
+ // Verified against Redis 7.x: PFADD key "" sets register 5938 to count=2
+ assert_eq!(murmurhash64a(b"", HLL_HASH_SEED), 0xD8DFEA6585BC9732);
+ }
+
+ #[test]
+ fn murmur_nonempty_deterministic() {
+ let h1 = murmurhash64a(b"hello", HLL_HASH_SEED);
+ let h2 = murmurhash64a(b"hello", HLL_HASH_SEED);
+ assert_eq!(h1, h2);
+ assert_ne!(h1, 0);
+ }
+
+ #[test]
+ fn murmur_different_inputs_differ() {
+ let h1 = murmurhash64a(b"hello", HLL_HASH_SEED);
+ let h2 = murmurhash64a(b"world", HLL_HASH_SEED);
+ assert_ne!(h1, h2);
+ }
+
+ #[test]
+ fn murmur_64byte_input() {
+ let data: Vec = (0u8..64).collect();
+ let h = murmurhash64a(&data, HLL_HASH_SEED);
+ assert_ne!(h, 0);
+ }
+
+ #[test]
+ fn dense_get_set_roundtrip() {
+ let mut regs = vec![0u8; (HLL_REGISTERS * HLL_BITS as usize + 7) / 8];
+ for reg in 0..HLL_REGISTERS {
+ let val = (reg % 63) as u8 + 1;
+ dense_set(&mut regs, reg, val);
+ assert_eq!(dense_get(®s, reg), val, "register {} failed", reg);
+ }
+ }
+
+ #[test]
+ fn dense_get_set_boundary_values() {
+ let mut regs = vec![0u8; (HLL_REGISTERS * HLL_BITS as usize + 7) / 8];
+ dense_set(&mut regs, 0, HLL_REGISTER_MAX);
+ assert_eq!(dense_get(®s, 0), HLL_REGISTER_MAX);
+ dense_set(&mut regs, 1, 1);
+ assert_eq!(dense_get(®s, 0), HLL_REGISTER_MAX);
+ assert_eq!(dense_get(®s, 1), 1);
+ }
+
+ #[test]
+ fn hll_new_sparse_header() {
+ let hll = Hll::new_sparse();
+ assert_eq!(&hll.buf[0..4], b"HYLL");
+ assert_eq!(hll.buf[4], HLL_SPARSE);
+ assert!(hll.is_sparse());
+ }
+
+ #[test]
+ fn hll_new_dense_header() {
+ let hll = Hll::new_dense();
+ assert_eq!(&hll.buf[0..4], b"HYLL");
+ assert_eq!(hll.buf[4], HLL_DENSE);
+ assert_eq!(hll.buf.len(), HLL_DENSE_SIZE);
+ }
+
+ #[test]
+ fn hll_is_hll() {
+ let hll = Hll::new_sparse();
+ let bytes = hll.into_bytes();
+ assert!(Hll::is_hll(&bytes));
+ assert!(!Hll::is_hll(b"not a hll"));
+ assert!(!Hll::is_hll(b"HYL"));
+ }
+
+ #[test]
+ fn hll_from_bytes_valid() {
+ let hll = Hll::new_sparse();
+ let bytes = hll.into_bytes();
+ let hll2 = Hll::from_bytes(bytes).unwrap();
+ assert!(hll2.is_sparse());
+ }
+
+ #[test]
+ fn hll_from_bytes_bad_magic() {
+ let mut buf = BytesMut::with_capacity(HLL_HDR_SIZE);
+ buf.put_slice(b"NOPE");
+ buf.put_bytes(0, HLL_HDR_SIZE - 4);
+ let result = Hll::from_bytes(buf.freeze());
+ assert_eq!(result.unwrap_err(), HllError::BadMagic);
+ }
+
+ #[test]
+ fn hll_from_bytes_truncated() {
+ let result = Hll::from_bytes(Bytes::from_static(b"HYL"));
+ assert_eq!(result.unwrap_err(), HllError::Truncated);
+ }
+
+ #[test]
+ fn ertl_sigma_zero() {
+ assert_eq!(hll_sigma(0.0), 0.0);
+ }
+
+ #[test]
+ fn ertl_sigma_one() {
+ assert!(hll_sigma(1.0).is_infinite());
+ }
+
+ #[test]
+ fn ertl_tau_zero() {
+ assert_eq!(hll_tau(0.0), 0.0);
+ }
+
+ #[test]
+ fn ertl_tau_one() {
+ assert_eq!(hll_tau(1.0), 0.0);
+ }
+
+ #[test]
+ fn hll_count_all_zeros() {
+ let mut reghisto = [0u32; 64];
+ reghisto[0] = HLL_REGISTERS as u32;
+ let c = hll_count(®histo);
+ assert_eq!(c, 0, "empty HLL should return 0");
+ }
+
+ // -- Full integration tests --
+
+ #[test]
+ fn add_single_element_sparse() {
+ let mut hll = Hll::new_sparse();
+ assert!(hll.is_sparse());
+ assert!(hll.add(b"hello"));
+ // Adding same element again should return false
+ assert!(!hll.add(b"hello"));
+ }
+
+ #[test]
+ fn add_empty_string_matches_redis() {
+ let mut hll = Hll::new_sparse();
+ assert!(hll.add(b""));
+ // Verify register placement: hash gives index=5938, count=2
+ // After promotion to verify, just check count works
+ let c = hll.count();
+ assert_eq!(c, 1);
+ }
+
+ #[test]
+ fn pfadd_monotonic() {
+ let mut hll = Hll::new_sparse();
+ let mut prev = 0u64;
+ for i in 0..1000u32 {
+ let s = i.to_string();
+ hll.add(s.as_bytes());
+ let c = hll.count();
+ assert!(c >= prev, "count decreased at i={}: {} < {}", i, c, prev);
+ prev = c;
+ }
+ }
+
+ #[test]
+ fn pfcount_10_unique() {
+ let mut hll = Hll::new_sparse();
+ for i in 0..10u32 {
+ let s = i.to_string();
+ hll.add(s.as_bytes());
+ }
+ let count = hll.count();
+ assert!(
+ (9..=11).contains(&count),
+ "pfcount 10: expected 9..=11, got {}",
+ count
+ );
+ }
+
+ #[test]
+ fn pfcount_1k_unique_within_1pct() {
+ let mut hll = Hll::new_sparse();
+ for i in 0..1000u32 {
+ let s = i.to_string();
+ hll.add(s.as_bytes());
+ }
+ let count = hll.count();
+ assert!(
+ (980..=1020).contains(&count),
+ "pfcount 1k: expected ~1000 (within 2%), got {}",
+ count
+ );
+ }
+
+ #[test]
+ fn pfcount_100k_unique_within_1pct() {
+ let mut hll = Hll::new_sparse();
+ for i in 0..100_000u32 {
+ let s = i.to_string();
+ hll.add(s.as_bytes());
+ }
+ let count = hll.count();
+ assert!(
+ (99_000..=101_000).contains(&count),
+ "pfcount 100k: expected 99_000..=101_000, got {}",
+ count
+ );
+ }
+
+ #[test]
+ fn pfmerge_register_max() {
+ let mut hll_a = Hll::new_sparse();
+ let mut hll_b = Hll::new_sparse();
+ for i in 0..500u32 {
+ hll_a.add(i.to_string().as_bytes());
+ }
+ for i in 250..750u32 {
+ hll_b.add(i.to_string().as_bytes());
+ }
+ hll_a.merge_from(&hll_b);
+ let count = hll_a.count();
+ // 750 unique elements, expect within ~2%
+ assert!(
+ (735..=765).contains(&count),
+ "pfmerge result: expected ~750, got {}",
+ count
+ );
+ }
+
+ #[test]
+ fn sparse_to_dense_promotion() {
+ let mut hll = Hll::new_sparse();
+ assert!(hll.is_sparse());
+ // Add enough elements to trigger promotion
+ for i in 0..5000u32 {
+ hll.add(i.to_string().as_bytes());
+ }
+ // After many adds, likely promoted to dense
+ // (sparse max is 3000 bytes, which is exceeded with many distinct values)
+ // Regardless of encoding, count should still be accurate
+ let count = hll.count();
+ assert!(
+ (4900..=5100).contains(&count),
+ "after promotion, count should be ~5000, got {}",
+ count
+ );
+ }
+
+ #[test]
+ fn count_caching() {
+ let mut hll = Hll::new_sparse();
+ hll.add(b"a");
+ hll.add(b"b");
+ let c1 = hll.count();
+ // Second call should use cache
+ let c2 = hll.count();
+ assert_eq!(c1, c2);
+ // After add, cache should be invalidated
+ hll.add(b"c");
+ let c3 = hll.count();
+ assert!(c3 >= c1);
+ }
+
+ #[test]
+ fn hll_wire_format_sparse_matches_redis() {
+ // Verify that PFADD "" produces the exact same sparse encoding as Redis
+ let mut hll = Hll::new_sparse();
+ hll.add(b"");
+ let bytes = hll.as_bytes();
+
+ // Expected from Redis: HYLL header + XZERO(5938) + VAL(2,1) + XZERO(10445)
+ assert_eq!(&bytes[0..4], b"HYLL");
+ assert_eq!(bytes[4], HLL_SPARSE);
+
+ // Decode sparse payload and verify structure
+ let payload = &bytes[HLL_HDR_SIZE..];
+ let (op1, c1) = sparse_decode(payload, 0).unwrap();
+ assert!(matches!(op1, SparseOp::XZero(5938)));
+ let (op2, c2) = sparse_decode(payload, c1).unwrap();
+ assert!(matches!(op2, SparseOp::Val(2, 1)));
+ let (op3, _c3) = sparse_decode(payload, c1 + c2).unwrap();
+ assert!(matches!(op3, SparseOp::XZero(10445)));
+ }
+
+ #[test]
+ fn merge_empty_into_populated() {
+ let mut hll_a = Hll::new_sparse();
+ for i in 0..100u32 {
+ hll_a.add(i.to_string().as_bytes());
+ }
+ let count_before = hll_a.count();
+
+ let hll_b = Hll::new_sparse(); // empty
+ hll_a.merge_from(&hll_b);
+ let count_after = hll_a.count();
+ assert_eq!(count_before, count_after);
+ }
+
+ #[test]
+ fn merge_populated_into_empty() {
+ let mut hll_a = Hll::new_sparse(); // empty
+ let mut hll_b = Hll::new_sparse();
+ for i in 0..100u32 {
+ hll_b.add(i.to_string().as_bytes());
+ }
+ let count_b = hll_b.count();
+ hll_a.merge_from(&hll_b);
+ let count_a = hll_a.count();
+ assert_eq!(count_a, count_b);
+ }
+}
diff --git a/src/storage/mod.rs b/src/storage/mod.rs
index 6e2acba7..3fea4e0c 100644
--- a/src/storage/mod.rs
+++ b/src/storage/mod.rs
@@ -8,6 +8,7 @@ pub mod db_read;
pub mod engine;
pub mod entry;
pub mod eviction;
+pub mod hll;
pub mod intset;
pub mod listpack;
pub mod stream;
diff --git a/tests/blocking_list_timeout.rs b/tests/blocking_list_timeout.rs
new file mode 100644
index 00000000..b98737dd
--- /dev/null
+++ b/tests/blocking_list_timeout.rs
@@ -0,0 +1,239 @@
+//! Integration tests for blocking list commands: BLPOP, BRPOP, BLMOVE,
+//! BLMPOP, BRPOPLPUSH, BZPOPMIN, BZPOPMAX.
+//!
+//! Requires a running moon server in sharded mode on port 16479:
+//! ./target/release/moon --port 16479 --shards 1
+//!
+//! Run with: bash scripts/run-blocking-tests.sh
+//!
+//! Compiles under both `runtime-tokio` and `runtime-monoio` feature gates.
+
+use std::time::Duration;
+
+use redis::AsyncCommands;
+
+const MOON_PORT: u16 = 16479;
+
+/// Get a multiplexed connection (good for non-blocking commands).
+async fn get_conn() -> redis::aio::MultiplexedConnection {
+ let client = redis::Client::open(format!("redis://127.0.0.1:{}/", MOON_PORT)).unwrap();
+ client.get_multiplexed_async_connection().await.unwrap()
+}
+
+/// Clean up test keys.
+async fn cleanup_keys(conn: &mut redis::aio::MultiplexedConnection, keys: &[&str]) {
+ for key in keys {
+ let _: Result<(), _> = redis::cmd("DEL").arg(*key).query_async(conn).await;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Test: BLPOP timeout returns nil (via redis-cli subprocess for true blocking)
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn blpop_timeout_returns_nil() {
+ let mut conn = get_conn().await;
+ cleanup_keys(&mut conn, &["empty_key_blpop"]).await;
+
+ // Use redis-cli subprocess for true blocking semantics
+ let start = std::time::Instant::now();
+ let output = tokio::process::Command::new("redis-cli")
+ .args([
+ "-p",
+ &MOON_PORT.to_string(),
+ "BLPOP",
+ "empty_key_blpop",
+ "1",
+ ])
+ .output()
+ .await
+ .unwrap();
+ let elapsed = start.elapsed();
+
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ // Redis returns empty string on nil/timeout
+ assert!(
+ stdout.trim().is_empty(),
+ "BLPOP should return nil on timeout, got: '{}'",
+ stdout.trim()
+ );
+ assert!(
+ elapsed.as_millis() >= 900,
+ "BLPOP should block for ~1s, elapsed={}ms",
+ elapsed.as_millis()
+ );
+}
+
+// ---------------------------------------------------------------------------
+// Test: BRPOP wakes on RPUSH (via redis-cli subprocess)
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn brpop_wakes_on_rpush() {
+ let mut conn = get_conn().await;
+ cleanup_keys(&mut conn, &["wake_key"]).await;
+
+ // Client A: start blocking BRPOP via redis-cli
+ let mut child = tokio::process::Command::new("redis-cli")
+ .args(["-p", &MOON_PORT.to_string(), "BRPOP", "wake_key", "5"])
+ .stdout(std::process::Stdio::piped())
+ .spawn()
+ .unwrap();
+
+ // Give Client A time to register
+ tokio::time::sleep(Duration::from_millis(300)).await;
+
+ // Client B: RPUSH to wake Client A
+ let _: () = conn.rpush("wake_key", "hello").await.unwrap();
+
+ // Wait for redis-cli to return
+ let output = tokio::time::timeout(Duration::from_secs(3), child.wait_with_output())
+ .await
+ .expect("timed out waiting for BRPOP wake")
+ .unwrap();
+
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ assert!(
+ stdout.contains("wake_key"),
+ "BRPOP should return the key name, got: '{}'",
+ stdout.trim()
+ );
+ assert!(
+ stdout.contains("hello"),
+ "BRPOP should return the value, got: '{}'",
+ stdout.trim()
+ );
+}
+
+// ---------------------------------------------------------------------------
+// Test: BLMPOP count greater than one
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn blmpop_count_greater_than_one() {
+ let mut conn = get_conn().await;
+ cleanup_keys(&mut conn, &["blmpop_key"]).await;
+
+ // Pre-populate list: a b c d e (left to right)
+ let _: () = redis::cmd("RPUSH")
+ .arg("blmpop_key")
+ .arg("a")
+ .arg("b")
+ .arg("c")
+ .arg("d")
+ .arg("e")
+ .query_async(&mut conn)
+ .await
+ .unwrap();
+
+ // BLMPOP timeout numkeys key LEFT COUNT 3 (immediate pop -- data available)
+ let result: redis::Value = redis::cmd("BLMPOP")
+ .arg(1) // timeout
+ .arg(1) // numkeys
+ .arg("blmpop_key")
+ .arg("LEFT")
+ .arg("COUNT")
+ .arg(3)
+ .query_async(&mut conn)
+ .await
+ .unwrap();
+
+ // Result: [key, [elem1, elem2, elem3]]
+ match result {
+ redis::Value::Array(outer) => {
+ assert_eq!(outer.len(), 2, "BLMPOP should return [key, elements]");
+ match &outer[0] {
+ redis::Value::BulkString(k) => {
+ assert_eq!(k, b"blmpop_key", "key should be blmpop_key");
+ }
+ other => panic!("expected BulkString for key, got {:?}", other),
+ }
+ match &outer[1] {
+ redis::Value::Array(elems) => {
+ assert_eq!(elems.len(), 3, "should pop 3 elements");
+ }
+ other => panic!("expected Array for elements, got {:?}", other),
+ }
+ }
+ other => panic!("expected Array from BLMPOP, got {:?}", other),
+ }
+
+ // Verify only 2 elements remain
+ let len: i64 = conn.llen("blmpop_key").await.unwrap();
+ assert_eq!(len, 2, "2 elements should remain after popping 3 from 5");
+}
+
+// ---------------------------------------------------------------------------
+// Test: BRPOPLPUSH legacy alias
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn brpoplpush_legacy_alias() {
+ let mut conn = get_conn().await;
+ cleanup_keys(&mut conn, &["brpl_src", "brpl_dst"]).await;
+
+ // Pre-populate source
+ let _: () = conn.rpush("brpl_src", "alpha").await.unwrap();
+ let _: () = conn.rpush("brpl_src", "beta").await.unwrap();
+
+ // BRPOPLPUSH src dst 0 => immediate pop (data available)
+ let result: String = redis::cmd("BRPOPLPUSH")
+ .arg("brpl_src")
+ .arg("brpl_dst")
+ .arg(0)
+ .query_async(&mut conn)
+ .await
+ .unwrap();
+
+ assert_eq!(result, "beta", "BRPOPLPUSH should return the moved element");
+
+ let src_len: i64 = conn.llen("brpl_src").await.unwrap();
+ let dst_len: i64 = conn.llen("brpl_dst").await.unwrap();
+ assert_eq!(src_len, 1, "source should have 1 element left");
+ assert_eq!(dst_len, 1, "destination should have 1 element");
+
+ let dst_val: Vec = conn.lrange("brpl_dst", 0, -1).await.unwrap();
+ assert_eq!(dst_val, vec!["beta"]);
+}
+
+// ---------------------------------------------------------------------------
+// Test: connection drop cleans registry (via redis-cli subprocess)
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn connection_drop_cleans_registry() {
+ let mut conn = get_conn().await;
+ cleanup_keys(&mut conn, &["drop_test_key"]).await;
+
+ // Start a blocking client via redis-cli, then kill it
+ let mut child = tokio::process::Command::new("redis-cli")
+ .args(["-p", &MOON_PORT.to_string(), "BLPOP", "drop_test_key", "30"])
+ .stdout(std::process::Stdio::null())
+ .spawn()
+ .unwrap();
+
+ // Wait for registration
+ tokio::time::sleep(Duration::from_millis(300)).await;
+
+ // Kill the client (simulates connection drop)
+ child.kill().await.unwrap();
+ let _ = child.wait().await;
+
+ // Wait for expire tick to clean up
+ tokio::time::sleep(Duration::from_millis(200)).await;
+
+ // Verify a new blocking client works normally (short timeout via redis-cli)
+ let output = tokio::process::Command::new("redis-cli")
+ .args(["-p", &MOON_PORT.to_string(), "BLPOP", "drop_test_key", "1"])
+ .output()
+ .await
+ .unwrap();
+
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ assert!(
+ stdout.trim().is_empty(),
+ "should timeout (no data in key), got: '{}'",
+ stdout.trim()
+ );
+}
diff --git a/tests/functions_fcall.rs b/tests/functions_fcall.rs
new file mode 100644
index 00000000..175df4eb
--- /dev/null
+++ b/tests/functions_fcall.rs
@@ -0,0 +1,232 @@
+//! Integration tests for Redis 7.0+ Functions API (FUNCTION LOAD/LIST/DELETE/FLUSH,
+//! FCALL, FCALL_RO).
+//!
+//! **Phase 101 limitation:** Functions are RAM-only. Not persisted across restarts.
+//! The `function_not_persistent_across_restart` test documents this known limitation.
+//!
+//! Requires a running moon server on the port specified by MOON_PORT (default 16479):
+//! ./target/release/moon --port 16479 --shards 1
+//!
+//! Run with: cargo test --release --test functions_fcall
+
+const MOON_PORT: u16 = 16479;
+
+/// Get a multiplexed connection.
+async fn get_conn() -> redis::aio::MultiplexedConnection {
+ let client = redis::Client::open(format!("redis://127.0.0.1:{}/", MOON_PORT)).unwrap();
+ client.get_multiplexed_async_connection().await.unwrap()
+}
+
+/// Helper: send a raw redis command and get the result as a RedisValue.
+async fn raw_cmd(
+ con: &mut redis::aio::MultiplexedConnection,
+ args: &[&str],
+) -> redis::RedisResult {
+ let mut cmd = redis::cmd(args[0]);
+ for arg in &args[1..] {
+ cmd.arg(*arg);
+ }
+ cmd.query_async(con).await
+}
+
+/// Clean up any function state before each test.
+async fn flush_functions(con: &mut redis::aio::MultiplexedConnection) {
+ let _: redis::RedisResult = raw_cmd(con, &["FUNCTION", "FLUSH"]).await;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn function_load_and_fcall() {
+ let mut con = get_conn().await;
+ flush_functions(&mut con).await;
+
+ let body = "#!lua name=mylib\nredis.register_function('hello', function() return 'world' end)";
+
+ // FUNCTION LOAD
+ let result = raw_cmd(&mut con, &["FUNCTION", "LOAD", body])
+ .await
+ .unwrap();
+ assert_eq!(result, redis::Value::BulkString(b"mylib".to_vec()));
+
+ // FCALL hello 0
+ let result = raw_cmd(&mut con, &["FCALL", "hello", "0"]).await.unwrap();
+ assert_eq!(result, redis::Value::BulkString(b"world".to_vec()));
+}
+
+#[tokio::test]
+async fn function_load_missing_header_errors() {
+ let mut con = get_conn().await;
+ flush_functions(&mut con).await;
+
+ // Body without shebang
+ let result = raw_cmd(&mut con, &["FUNCTION", "LOAD", "return 1"]).await;
+ assert!(result.is_err());
+ let err_str = format!("{}", result.unwrap_err());
+ assert!(
+ err_str.contains("Missing library metadata") || err_str.contains("Missing library"),
+ "Unexpected error: {err_str}"
+ );
+}
+
+#[tokio::test]
+async fn function_load_duplicate_without_replace_errors() {
+ let mut con = get_conn().await;
+ flush_functions(&mut con).await;
+
+ let body =
+ "#!lua name=duplib\nredis.register_function('dup_hello', function() return 'world' end)";
+
+ // First load succeeds
+ let _ = raw_cmd(&mut con, &["FUNCTION", "LOAD", body])
+ .await
+ .unwrap();
+
+ // Second load without REPLACE fails
+ let result = raw_cmd(&mut con, &["FUNCTION", "LOAD", body]).await;
+ assert!(result.is_err());
+ let err_str = format!("{}", result.unwrap_err());
+ assert!(
+ err_str.contains("already exists"),
+ "Unexpected error: {err_str}"
+ );
+}
+
+#[tokio::test]
+async fn function_load_replace_succeeds() {
+ let mut con = get_conn().await;
+ flush_functions(&mut con).await;
+
+ let body1 =
+ "#!lua name=replib\nredis.register_function('rep_hello', function() return 'world' end)";
+ let body2 =
+ "#!lua name=replib\nredis.register_function('rep_hello', function() return 'replaced' end)";
+
+ let _ = raw_cmd(&mut con, &["FUNCTION", "LOAD", body1])
+ .await
+ .unwrap();
+
+ // REPLACE should succeed
+ let result = raw_cmd(&mut con, &["FUNCTION", "LOAD", "REPLACE", body2])
+ .await
+ .unwrap();
+ assert_eq!(result, redis::Value::BulkString(b"replib".to_vec()));
+
+ // Verify the function was replaced
+ let result = raw_cmd(&mut con, &["FCALL", "rep_hello", "0"])
+ .await
+ .unwrap();
+ assert_eq!(result, redis::Value::BulkString(b"replaced".to_vec()));
+}
+
+#[tokio::test]
+async fn function_list_returns_libraries() {
+ let mut con = get_conn().await;
+ flush_functions(&mut con).await;
+
+ let body =
+ "#!lua name=listlib\nredis.register_function('list_hello', function() return 'world' end)";
+ let _ = raw_cmd(&mut con, &["FUNCTION", "LOAD", body])
+ .await
+ .unwrap();
+
+ let result = raw_cmd(&mut con, &["FUNCTION", "LIST"]).await.unwrap();
+ // Should be an array containing at least one library descriptor
+ let list_str = format!("{:?}", result);
+ assert!(
+ list_str.contains("listlib"),
+ "FUNCTION LIST should contain listlib, got: {list_str}"
+ );
+}
+
+#[tokio::test]
+async fn function_delete_removes() {
+ let mut con = get_conn().await;
+ flush_functions(&mut con).await;
+
+ let body =
+ "#!lua name=dellib\nredis.register_function('del_hello', function() return 'world' end)";
+ let _ = raw_cmd(&mut con, &["FUNCTION", "LOAD", body])
+ .await
+ .unwrap();
+
+ // DELETE
+ let result = raw_cmd(&mut con, &["FUNCTION", "DELETE", "dellib"])
+ .await
+ .unwrap();
+ assert_eq!(result, redis::Value::Okay);
+
+ // FCALL should fail
+ let result = raw_cmd(&mut con, &["FCALL", "del_hello", "0"]).await;
+ assert!(result.is_err());
+ let err_str = format!("{}", result.unwrap_err());
+ assert!(
+ err_str.contains("Function not found"),
+ "Expected function not found error, got: {err_str}"
+ );
+}
+
+#[tokio::test]
+async fn fcall_ro_rejects_writes() {
+ let mut con = get_conn().await;
+ flush_functions(&mut con).await;
+
+ let body = "#!lua name=rolib\nredis.register_function('writer', function() return redis.call('SET', 'k', 'v') end)";
+ let _ = raw_cmd(&mut con, &["FUNCTION", "LOAD", body])
+ .await
+ .unwrap();
+
+ // FCALL_RO should reject writes
+ let result = raw_cmd(&mut con, &["FCALL_RO", "writer", "0"]).await;
+ assert!(result.is_err());
+ let err_str = format!("{}", result.unwrap_err());
+ assert!(
+ err_str.contains("Write commands are not allowed") || err_str.contains("read-only"),
+ "Expected write rejection error, got: {err_str}"
+ );
+}
+
+#[tokio::test]
+async fn function_dump_restore_stats_deferred() {
+ let mut con = get_conn().await;
+
+ // FUNCTION DUMP
+ let result = raw_cmd(&mut con, &["FUNCTION", "DUMP"]).await;
+ assert!(result.is_err());
+ let err_str = format!("{}", result.unwrap_err());
+ assert!(
+ err_str.contains("DUMP not supported") && err_str.contains("Phase 101"),
+ "Expected DUMP deferred error, got: {err_str}"
+ );
+
+ // FUNCTION RESTORE
+ let result = raw_cmd(&mut con, &["FUNCTION", "RESTORE", "payload"]).await;
+ assert!(result.is_err());
+ let err_str = format!("{}", result.unwrap_err());
+ assert!(
+ err_str.contains("RESTORE not supported") && err_str.contains("Phase 101"),
+ "Expected RESTORE deferred error, got: {err_str}"
+ );
+
+ // FUNCTION STATS
+ let result = raw_cmd(&mut con, &["FUNCTION", "STATS"]).await;
+ assert!(result.is_err());
+ let err_str = format!("{}", result.unwrap_err());
+ assert!(
+ err_str.contains("STATS not supported") && err_str.contains("Phase 101"),
+ "Expected STATS deferred error, got: {err_str}"
+ );
+}
+
+#[tokio::test]
+#[ignore = "Phase 101: FUNCTION is RAM-only; persistence deferred"]
+async fn function_not_persistent_across_restart() {
+ // This test documents the known limitation that functions are RAM-only
+ // and will not survive a server restart. When persistence is added
+ // (future phase), this test should be un-ignored and verify that
+ // functions loaded before restart are available after restart.
+ //
+ // Cannot be tested in this harness as it requires server restart.
+}
diff --git a/tests/hll_vectors.rs b/tests/hll_vectors.rs
new file mode 100644
index 00000000..558f9444
--- /dev/null
+++ b/tests/hll_vectors.rs
@@ -0,0 +1,100 @@
+//! HyperLogLog test vectors — pure-Rust unit tests for the HLL primitive.
+//!
+//! Tests MurmurHash64A known-answer values, cardinality estimation accuracy,
+//! merge correctness, and HYLL header format.
+
+use moon::storage::hll::{HLL_HASH_SEED, Hll, murmurhash64a};
+
+#[test]
+fn murmur_empty_string_kat() {
+ // MurmurHash64A("", seed=0xadc83b19) — verified against Redis 7.x sparse encoding:
+ // PFADD key "" sets register 5938 to count=2, which matches this hash.
+ assert_eq!(murmurhash64a(b"", HLL_HASH_SEED), 0xD8DFEA6585BC9732);
+}
+
+#[test]
+fn murmur_hello_kat() {
+ let h = murmurhash64a(b"hello", HLL_HASH_SEED);
+ assert_ne!(h, 0);
+}
+
+#[test]
+fn murmur_world_kat() {
+ let h1 = murmurhash64a(b"hello", HLL_HASH_SEED);
+ let h2 = murmurhash64a(b"world", HLL_HASH_SEED);
+ assert_ne!(h1, h2);
+}
+
+#[test]
+fn murmur_64byte_kat() {
+ let data: Vec = (0u8..64).collect();
+ let h = murmurhash64a(&data, HLL_HASH_SEED);
+ assert_ne!(h, 0);
+}
+
+#[test]
+fn hyll_header_bytes() {
+ let hll = Hll::new_sparse();
+ let bytes = hll.into_bytes();
+ assert_eq!(&bytes[0..4], b"HYLL");
+ assert!(bytes[4] == 0 || bytes[4] == 1);
+}
+
+#[test]
+fn pfadd_monotonic() {
+ let mut hll = Hll::new_sparse();
+ let mut prev = 0u64;
+ for i in 0..1000u32 {
+ hll.add(i.to_string().as_bytes());
+ let c = hll.count();
+ assert!(c >= prev, "count decreased at i={}: {} < {}", i, c, prev);
+ prev = c;
+ }
+}
+
+#[test]
+fn pfcount_1k_unique_within_1pct() {
+ let mut hll = Hll::new_sparse();
+ for i in 0..1000u32 {
+ hll.add(i.to_string().as_bytes());
+ }
+ let count = hll.count();
+ assert!(
+ (980..=1020).contains(&count),
+ "pfcount 1k: expected ~1000 (within 2%), got {}",
+ count
+ );
+}
+
+#[test]
+fn pfcount_100k_unique_within_1pct() {
+ let mut hll = Hll::new_sparse();
+ for i in 0..100_000u32 {
+ hll.add(i.to_string().as_bytes());
+ }
+ let count = hll.count();
+ assert!(
+ (99_000..=101_000).contains(&count),
+ "pfcount 100k: expected 99_000..=101_000, got {}",
+ count
+ );
+}
+
+#[test]
+fn pfmerge_dense_sparse_max_register() {
+ let mut hll_a = Hll::new_sparse();
+ let mut hll_b = Hll::new_sparse();
+ for i in 0..500u32 {
+ hll_a.add(i.to_string().as_bytes());
+ }
+ for i in 250..750u32 {
+ hll_b.add(i.to_string().as_bytes());
+ }
+ hll_a.merge_from(&hll_b);
+ let count = hll_a.count();
+ assert!(
+ (735..=765).contains(&count),
+ "pfmerge result: expected ~750, got {}",
+ count
+ );
+}
diff --git a/tests/hll_wire_compat.rs b/tests/hll_wire_compat.rs
new file mode 100644
index 00000000..f21d2cc8
--- /dev/null
+++ b/tests/hll_wire_compat.rs
@@ -0,0 +1,33 @@
+//! HLL wire compatibility tests — byte-for-byte DUMP equality vs redis-server 7.x.
+//!
+//! These tests spawn a moon server and a real redis-server, perform identical
+//! PFADD sequences on both, then compare DUMP output byte-for-byte.
+//!
+//! Gated on Linux + redis-server availability (not available in all CI envs).
+
+// TODO(task3): uncomment test bodies after command dispatch lands
+// Tests require both moon server and redis-server on PATH.
+
+#[test]
+#[ignore] // Enable after Task 3 wires PFADD/PFCOUNT/PFMERGE dispatch
+fn hll_wire_compat_small_sequence() {
+ // PFADD key a b c on both moon and redis-server
+ // DUMP key on both
+ // assert_eq!(moon_dump, redis_dump)
+}
+
+#[test]
+#[ignore] // Enable after Task 3 wires PFADD/PFCOUNT/PFMERGE dispatch
+fn hll_wire_compat_medium_sequence() {
+ // PFADD key x1..x100 on both
+ // DUMP key on both
+ // assert_eq!(moon_dump, redis_dump)
+}
+
+#[test]
+#[ignore] // Enable after Task 3 wires PFADD/PFCOUNT/PFMERGE dispatch
+fn hll_wire_compat_large_sequence() {
+ // PFADD key x1..x10000 on both
+ // DUMP key on both
+ // assert_eq!(moon_dump, redis_dump)
+}