shardmap 0.3.1

Sharded embedded in-memory map with optional cache, protocol, and server internals
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use bytes::BytesMut;

use crate::commands::redis::{
    bulk, define_redis_command, eq_ignore_ascii_case, error, int, write_frame, write_resp_null,
    wrong_arity,
};
use crate::protocol::Frame;
#[cfg(feature = "server")]
use crate::server::wire::ServerWire;
use crate::storage::EmbeddedStore;

define_redis_command!(Object, "OBJECT", false);

const NO_SUCH_KEY: &str = "ERR no such key";
const LFU_POLICY: &str = "ERR An LFU maxmemory policy is not selected, access frequency not tracked. Please note that when switching between maxmemory policies at runtime LFU and LRU data will take some time to adjust.";

const OBJECT_HELP: &[&str] = &[
    "OBJECT ENCODING <key>",
    "OBJECT FREQ <key>",
    "OBJECT IDLETIME <key>",
    "OBJECT REFCOUNT <key>",
    "OBJECT HELP",
];

impl crate::commands::redis::RedisCommand for Object {
    fn execute(store: &EmbeddedStore, args: &[&[u8]]) -> Frame {
        match args {
            [subcommand] if eq_ignore_ascii_case(subcommand, b"HELP") => Frame::Array(
                OBJECT_HELP
                    .iter()
                    .map(|line| bulk(line.as_bytes().to_vec()))
                    .collect(),
            ),
            [subcommand, key] if eq_ignore_ascii_case(subcommand, b"ENCODING") => {
                match store.object_encoding(key) {
                    Some(encoding) => bulk(encoding.as_bytes().to_vec()),
                    None => Frame::Null,
                }
            }
            [subcommand, key] if eq_ignore_ascii_case(subcommand, b"REFCOUNT") => {
                if store.object_encoding(key).is_some() {
                    int(1)
                } else {
                    error(NO_SUCH_KEY)
                }
            }
            [subcommand, key] if eq_ignore_ascii_case(subcommand, b"IDLETIME") => {
                if store.object_encoding(key).is_some() {
                    int(0)
                } else {
                    error(NO_SUCH_KEY)
                }
            }
            [subcommand, _key] if eq_ignore_ascii_case(subcommand, b"FREQ") => error(LFU_POLICY),
            [_, _] => error("ERR syntax error"),
            _ => wrong_arity("OBJECT"),
        }
    }

    #[cfg(feature = "server")]
    fn write_resp(store: &EmbeddedStore, args: &[&[u8]], out: &mut BytesMut) {
        match args {
            [subcommand, key] if eq_ignore_ascii_case(subcommand, b"ENCODING") => {
                match store.object_encoding(key) {
                    Some("raw") => out.extend_from_slice(b"$3\r\nraw\r\n"),
                    Some(encoding) => ServerWire::write_resp_blob_string(out, encoding.as_bytes()),
                    None => write_resp_null(out),
                }
            }
            _ => write_frame(out, &Self::execute(store, args)),
        }
    }
}