Function handle_zrange

nodedb/src/control/server/resp/handler_sorted.rs:142–202

ZRANGE key start stop — returns members in rank range [start, stop] (0-based).

(
    cmd: &RespCommand,
    session: &RespSession,
    state: &SharedState,
)

/// ZRANGE key start stop — returns members in rank range [start, stop] (0-based).
pub(super) async fn handle_zrange(
    cmd: &RespCommand,
    session: &RespSession,
    state: &SharedState,
) -> RespValue {
    if cmd.argc() < 2 {
        return RespValue::err("ERR wrong number of arguments for 'zrange' command");
    }

    let start = cmd.arg_i64(0).unwrap_or(0);
    let stop = cmd.arg_i64(1).unwrap_or(-1);

    // Fetch enough entries to cover the range.
    // ZRANGE uses 0-based inclusive indices; negative means from end.
    // We'll fetch top_k with k = stop + 1 (or all if stop is negative).
    let k = if stop < 0 {
        u32::MAX
    } else {
        (stop + 1) as u32
    };

    let plan = PhysicalPlan::Kv(KvOp::SortedIndexTopK {
        index_name: session.collection.clone(),
        k,
    });

    match dispatch_kv(state, session, plan).await {
        Ok(resp) if resp.status == Status::Ok => {
            let rows: Vec<serde_json::Value> =
                sonic_rs::from_slice(&resp.payload).unwrap_or_default();
            let total = rows.len() as i64;

            let actual_start = if start < 0 {
                (total + start).max(0) as usize
            } else {
                start as usize
            };
            let actual_stop = if stop < 0 {
                (total + stop).max(0) as usize
            } else {
                (stop as usize).min(rows.len().saturating_sub(1))
            };

            if actual_start > actual_stop || actual_start >= rows.len() {
                return RespValue::array(vec![]);
            }

            let items: Vec<RespValue> = rows[actual_start..=actual_stop]
                .iter()
                .filter_map(|row| {
                    row.get("key")
                        .and_then(|v| v.as_str())
                        .map(|k| RespValue::bulk(k.as_bytes().to_vec()))
                })
                .collect();
            RespValue::array(items)
        }
        Ok(_) => RespValue::array(vec![]),