redis_event/cmd/
strings.rs

1/*!
2Strings相关的命令定义、解析
3
4所有涉及到的命令参考[Redis Command Reference]
5
6[Redis Command Reference]: https://redis.io/commands#string
7*/
8
9use core::slice::Iter;
10
11use crate::cmd::strings::Op::{AND, NOT, OR, XOR};
12
13#[derive(Debug)]
14pub struct APPEND<'a> {
15    pub key: &'a [u8],
16    pub value: &'a [u8],
17}
18
19pub(crate) fn parse_append(mut iter: Iter<Vec<u8>>) -> APPEND {
20    let key = iter.next().unwrap();
21    let value = iter.next().unwrap();
22    APPEND { key, value }
23}
24
25#[derive(Debug)]
26pub struct BITFIELD<'a> {
27    pub key: &'a [u8],
28    pub statements: Option<Vec<Operation<'a>>>,
29    pub overflows: Option<Vec<Overflow>>,
30}
31
32#[derive(Debug)]
33pub enum Operation<'a> {
34    GET(Get<'a>),
35    INCRBY(IncrBy<'a>),
36    SET(Set<'a>),
37}
38
39#[derive(Debug)]
40pub struct Get<'a> {
41    pub _type: &'a [u8],
42    pub offset: &'a [u8],
43}
44
45#[derive(Debug)]
46pub struct IncrBy<'a> {
47    pub _type: &'a [u8],
48    pub offset: &'a [u8],
49    pub increment: &'a [u8],
50}
51
52#[derive(Debug)]
53pub struct Set<'a> {
54    pub _type: &'a [u8],
55    pub offset: &'a [u8],
56    pub value: &'a [u8],
57}
58
59#[derive(Debug)]
60pub enum Overflow {
61    WRAP,
62    SAT,
63    FAIL,
64}
65
66pub(crate) fn parse_bitfield(mut iter: Iter<Vec<u8>>) -> BITFIELD {
67    let key = iter.next().unwrap();
68
69    let mut statements = Vec::new();
70    let mut overflows = Vec::new();
71    while let Some(next_arg) = iter.next() {
72        let arg_upper = &String::from_utf8_lossy(next_arg).to_uppercase();
73        if arg_upper == "GET" {
74            let _type = iter.next().expect("bitfield 缺失get type");
75            let offset = iter.next().expect("bitfield 缺失get offset");
76            statements.push(Operation::GET(Get { _type, offset }));
77        } else if arg_upper == "SET" {
78            let _type = iter.next().unwrap();
79            let offset = iter.next().expect("bitfield 缺失SET offset");
80            let value = iter.next().expect("bitfield 缺失SET offset");
81            statements.push(Operation::SET(Set { _type, offset, value }));
82        } else if arg_upper == "INCRBY" {
83            let _type = iter.next().expect("bitfield 缺失INCR type");
84            let offset = iter.next().expect("bitfield 缺失INCR offset");
85            let increment = iter.next().expect("bitfield 缺失INCR offset");
86            statements.push(Operation::INCRBY(IncrBy {
87                _type,
88                offset,
89                increment,
90            }));
91        } else if arg_upper == "OVERFLOW" {
92            let _type = String::from_utf8_lossy(iter.next().expect("bitfield 缺失OVERFLOW type"));
93            let type_upper = &_type.to_uppercase();
94            if type_upper == "FAIL" {
95                overflows.push(Overflow::FAIL);
96            } else if type_upper == "SAT" {
97                overflows.push(Overflow::SAT);
98            } else if type_upper == "WRAP" {
99                overflows.push(Overflow::WRAP);
100            }
101        }
102    }
103
104    let _statements;
105    if statements.is_empty() {
106        _statements = None;
107    } else {
108        _statements = Some(statements);
109    }
110    let _overflows;
111    if overflows.is_empty() {
112        _overflows = None;
113    } else {
114        _overflows = Some(overflows);
115    }
116    BITFIELD {
117        key,
118        statements: _statements,
119        overflows: _overflows,
120    }
121}
122
123#[derive(Debug)]
124pub struct BITOP<'a> {
125    pub operation: Op,
126    pub dest_key: &'a [u8],
127    pub keys: Vec<&'a Vec<u8>>,
128}
129
130#[derive(Debug)]
131pub enum Op {
132    AND,
133    OR,
134    XOR,
135    NOT,
136}
137
138pub(crate) fn parse_bitop(mut iter: Iter<Vec<u8>>) -> BITOP {
139    let operation;
140    let op = String::from_utf8_lossy(iter.next().unwrap()).to_uppercase();
141    if &op == "AND" {
142        operation = AND;
143    } else if &op == "OR" {
144        operation = OR;
145    } else if &op == "XOR" {
146        operation = XOR;
147    } else if &op == "NOT" {
148        operation = NOT;
149    } else {
150        panic!("bitop命令缺失operation")
151    }
152    let dest_key = iter.next().unwrap();
153
154    let mut keys = Vec::new();
155    while let Some(next_arg) = iter.next() {
156        keys.push(next_arg);
157    }
158    if keys.is_empty() {
159        panic!("bitop命令缺失input key")
160    }
161    BITOP {
162        operation,
163        dest_key,
164        keys,
165    }
166}
167
168#[derive(Debug)]
169pub struct SET<'a> {
170    pub key: &'a [u8],
171    pub value: &'a [u8],
172    pub expire: Option<(ExpireType, &'a Vec<u8>)>,
173    pub exist_type: Option<ExistType>,
174    pub keep_ttl: Option<bool>,
175}
176
177#[derive(Debug)]
178pub enum ExpireType {
179    // seconds -- Set the specified expire time, in seconds.
180    EX,
181    // milliseconds -- Set the specified expire time, in milliseconds.
182    PX,
183}
184
185#[derive(Debug)]
186pub enum ExistType {
187    // Only set the key if it does not already exist.
188    NX,
189    // Only set the key if it already exist.
190    XX,
191}
192
193pub(crate) fn parse_set(mut iter: Iter<Vec<u8>>) -> SET {
194    let key = iter.next().unwrap();
195
196    let value = iter.next().unwrap();
197
198    let mut expire_time = None;
199    let mut expire_type = None;
200    let mut exist_type = None;
201    let mut expire = None;
202    let mut keep_ttl = None;
203
204    for arg in iter {
205        let arg_string = String::from_utf8_lossy(arg);
206        let p_arg = &arg_string.to_uppercase();
207        if p_arg == "EX" {
208            expire_type = Some(ExpireType::EX);
209        } else if p_arg == "PX" {
210            expire_type = Some(ExpireType::PX);
211        } else if p_arg == "NX" {
212            exist_type = Some(ExistType::NX);
213        } else if p_arg == "XX" {
214            exist_type = Some(ExistType::XX);
215        } else if p_arg == "KEEPTTL" {
216            keep_ttl = Some(true)
217        } else {
218            // 读取过期时间
219            expire_time = Some(arg);
220        }
221    }
222    if expire_type.is_some() && expire_time.is_some() {
223        expire = Some((expire_type.unwrap(), expire_time.unwrap()));
224    }
225    SET {
226        key,
227        value,
228        exist_type,
229        expire,
230        keep_ttl,
231    }
232}
233
234#[derive(Debug)]
235pub struct SETEX<'a> {
236    pub key: &'a [u8],
237    pub seconds: &'a [u8],
238    pub value: &'a [u8],
239}
240
241pub(crate) fn parse_setex(mut iter: Iter<Vec<u8>>) -> SETEX {
242    let key = iter.next().unwrap();
243    let seconds = iter.next().unwrap();
244    let value = iter.next().unwrap();
245    SETEX { key, seconds, value }
246}
247
248#[derive(Debug)]
249pub struct SETNX<'a> {
250    pub key: &'a [u8],
251    pub value: &'a [u8],
252}
253
254pub(crate) fn parse_setnx(mut iter: Iter<Vec<u8>>) -> SETNX {
255    let key = iter.next().unwrap();
256    let value = iter.next().unwrap();
257    SETNX { key, value }
258}
259
260#[derive(Debug)]
261pub struct PSETEX<'a> {
262    pub key: &'a [u8],
263    pub milliseconds: &'a [u8],
264    pub value: &'a [u8],
265}
266
267pub(crate) fn parse_psetex(mut iter: Iter<Vec<u8>>) -> PSETEX {
268    let key = iter.next().unwrap();
269    let milliseconds = iter.next().unwrap();
270    let value = iter.next().unwrap();
271    PSETEX {
272        key,
273        milliseconds,
274        value,
275    }
276}
277
278#[derive(Debug)]
279pub struct SETRANGE<'a> {
280    pub key: &'a [u8],
281    pub offset: &'a [u8],
282    pub value: &'a [u8],
283}
284
285pub(crate) fn parse_setrange(mut iter: Iter<Vec<u8>>) -> SETRANGE {
286    let key = iter.next().unwrap();
287    let offset = iter.next().unwrap();
288    let value = iter.next().unwrap();
289    SETRANGE { key, offset, value }
290}
291
292#[derive(Debug)]
293pub struct DECR<'a> {
294    pub key: &'a [u8],
295}
296
297pub(crate) fn parse_decr(mut iter: Iter<Vec<u8>>) -> DECR {
298    let key = iter.next().unwrap();
299    DECR { key }
300}
301
302#[derive(Debug)]
303pub struct DECRBY<'a> {
304    pub key: &'a [u8],
305    pub decrement: &'a [u8],
306}
307
308pub(crate) fn parse_decrby(mut iter: Iter<Vec<u8>>) -> DECRBY {
309    let key = iter.next().unwrap();
310    let decrement = iter.next().unwrap();
311    DECRBY { key, decrement }
312}
313
314#[derive(Debug)]
315pub struct INCR<'a> {
316    pub key: &'a [u8],
317}
318
319pub(crate) fn parse_incr(mut iter: Iter<Vec<u8>>) -> INCR {
320    let key = iter.next().unwrap();
321    INCR { key }
322}
323
324#[derive(Debug)]
325pub struct INCRBY<'a> {
326    pub key: &'a [u8],
327    pub increment: &'a [u8],
328}
329
330pub(crate) fn parse_incrby(mut iter: Iter<Vec<u8>>) -> INCRBY {
331    let key = iter.next().unwrap();
332    let increment = iter.next().unwrap();
333    INCRBY { key, increment }
334}
335
336#[derive(Debug)]
337pub struct KeyValue<'a> {
338    pub key: &'a [u8],
339    pub value: &'a [u8],
340}
341
342#[derive(Debug)]
343pub struct MSET<'a> {
344    pub key_values: Vec<KeyValue<'a>>,
345}
346
347pub(crate) fn parse_mset(mut iter: Iter<Vec<u8>>) -> MSET {
348    let mut key_values = Vec::new();
349    while let Some(key) = iter.next() {
350        if let Some(value) = iter.next() {
351            key_values.push(KeyValue { key, value });
352        }
353    }
354    if key_values.is_empty() {
355        panic!("mset命令缺失key value");
356    }
357    MSET { key_values }
358}
359
360#[derive(Debug)]
361pub struct MSETNX<'a> {
362    pub key_values: Vec<KeyValue<'a>>,
363}
364
365pub(crate) fn parse_msetnx(mut iter: Iter<Vec<u8>>) -> MSETNX {
366    let mut key_values = Vec::new();
367    while let Some(key) = iter.next() {
368        if let Some(value) = iter.next() {
369            key_values.push(KeyValue { key, value });
370        }
371    }
372    if key_values.is_empty() {
373        panic!("msetnx命令缺失key value");
374    }
375    MSETNX { key_values }
376}
377
378#[derive(Debug)]
379pub struct SETBIT<'a> {
380    pub key: &'a [u8],
381    pub offset: &'a [u8],
382    pub value: &'a [u8],
383}
384
385pub(crate) fn parse_setbit(mut iter: Iter<Vec<u8>>) -> SETBIT {
386    let key = iter.next().unwrap();
387    let offset = iter.next().unwrap();
388    let value = iter.next().unwrap();
389    SETBIT { key, value, offset }
390}
391
392#[derive(Debug)]
393pub struct GETSET<'a> {
394    pub key: &'a [u8],
395    pub value: &'a [u8],
396}
397
398pub(crate) fn parse_getset(mut iter: Iter<Vec<u8>>) -> GETSET {
399    let key = iter.next().unwrap();
400    let value = iter.next().unwrap();
401    GETSET { key, value }
402}
redis_event/cmd/strings.rs

redis_event/cmd/
strings.rs
