redis_event/cmd/
keys.rs

1/*!
2Keys相关的命令定义、解析
3
4所有涉及到的命令参考[Redis Command Reference]
5
6[Redis Command Reference]: https://redis.io/commands#generic
7*/
8
9use std::slice::Iter;
10
11use crate::cmd::keys::ORDER::{ASC, DESC};
12
13#[derive(Debug)]
14pub struct DEL<'a> {
15    pub keys: Vec<&'a Vec<u8>>,
16}
17
18pub(crate) fn parse_del(iter: Iter<Vec<u8>>) -> DEL {
19    let mut keys = Vec::new();
20    for next_key in iter {
21        keys.push(next_key);
22    }
23    DEL { keys }
24}
25
26#[derive(Debug)]
27pub struct PERSIST<'a> {
28    pub key: &'a [u8],
29}
30
31pub(crate) fn parse_persist(mut iter: Iter<Vec<u8>>) -> PERSIST {
32    let key = iter.next().unwrap();
33    PERSIST { key }
34}
35
36#[derive(Debug)]
37pub struct EXPIRE<'a> {
38    pub key: &'a [u8],
39    pub seconds: &'a [u8],
40}
41
42pub(crate) fn parse_expire(mut iter: Iter<Vec<u8>>) -> EXPIRE {
43    let key = iter.next().unwrap();
44    let seconds = iter.next().unwrap();
45    EXPIRE { key, seconds }
46}
47
48#[derive(Debug)]
49pub struct PEXPIRE<'a> {
50    pub key: &'a [u8],
51    pub milliseconds: &'a [u8],
52}
53
54pub(crate) fn parse_pexpire(mut iter: Iter<Vec<u8>>) -> PEXPIRE {
55    let key = iter.next().unwrap();
56    let milliseconds = iter.next().unwrap();
57    PEXPIRE { key, milliseconds }
58}
59
60#[derive(Debug)]
61pub struct EXPIREAT<'a> {
62    pub key: &'a [u8],
63    pub timestamp: &'a [u8],
64}
65
66pub(crate) fn parse_expireat(mut iter: Iter<Vec<u8>>) -> EXPIREAT {
67    let key = iter.next().unwrap();
68    let timestamp = iter.next().unwrap();
69    EXPIREAT { key, timestamp }
70}
71
72#[derive(Debug)]
73pub struct PEXPIREAT<'a> {
74    pub key: &'a [u8],
75    pub mill_timestamp: &'a [u8],
76}
77
78pub(crate) fn parse_pexpireat(mut iter: Iter<Vec<u8>>) -> PEXPIREAT {
79    let key = iter.next().unwrap();
80    let mill_timestamp = iter.next().unwrap();
81    PEXPIREAT { key, mill_timestamp }
82}
83
84#[derive(Debug)]
85pub struct MOVE<'a> {
86    pub key: &'a [u8],
87    pub db: &'a [u8],
88}
89
90pub(crate) fn parse_move(mut iter: Iter<Vec<u8>>) -> MOVE {
91    let key = iter.next().unwrap();
92    let db = iter.next().unwrap();
93    MOVE { key, db }
94}
95
96#[derive(Debug)]
97pub struct RENAME<'a> {
98    pub key: &'a [u8],
99    pub new_key: &'a [u8],
100}
101
102pub(crate) fn parse_rename(mut iter: Iter<Vec<u8>>) -> RENAME {
103    let key = iter.next().unwrap();
104    let new_key = iter.next().unwrap();
105    RENAME { key, new_key }
106}
107
108#[derive(Debug)]
109pub struct RENAMENX<'a> {
110    pub key: &'a [u8],
111    pub new_key: &'a [u8],
112}
113
114pub(crate) fn parse_renamenx(mut iter: Iter<Vec<u8>>) -> RENAMENX {
115    let key = iter.next().unwrap();
116    let new_key = iter.next().unwrap();
117    RENAMENX { key, new_key }
118}
119
120#[derive(Debug)]
121pub struct RESTORE<'a> {
122    pub key: &'a [u8],
123    pub ttl: &'a [u8],
124    pub value: &'a [u8],
125    pub replace: Option<bool>,
126    pub abs_ttl: Option<bool>,
127    pub idle_time: Option<&'a [u8]>,
128    pub freq: Option<&'a [u8]>,
129}
130
131pub(crate) fn parse_restore(mut iter: Iter<Vec<u8>>) -> RESTORE {
132    let key = iter.next().unwrap();
133    let ttl = iter.next().unwrap();
134    let value = iter.next().unwrap();
135    let mut replace = None;
136    let mut abs_ttl = None;
137    let mut idle_time = None;
138    let mut freq = None;
139    while let Some(next_arg) = iter.next() {
140        let arg = String::from_utf8_lossy(next_arg).to_uppercase();
141        if &arg == "REPLACE" {
142            replace = Some(true);
143        } else if &arg == "ABSTTL" {
144            abs_ttl = Some(true);
145        } else if &arg == "IDLETIME" {
146            idle_time = Some(iter.next().unwrap().as_slice());
147        } else if &arg == "FREQ" {
148            freq = Some(iter.next().unwrap().as_slice());
149        }
150    }
151    RESTORE {
152        key,
153        ttl,
154        value,
155        replace,
156        abs_ttl,
157        idle_time,
158        freq,
159    }
160}
161
162#[derive(Debug)]
163pub struct SORT<'a> {
164    pub key: &'a [u8],
165    pub by_pattern: Option<&'a [u8]>,
166    pub limit: Option<LIMIT<'a>>,
167    pub get_patterns: Option<Vec<&'a [u8]>>,
168    pub order: Option<ORDER>,
169    pub alpha: Option<bool>,
170    pub destination: Option<&'a [u8]>,
171}
172
173#[derive(Debug)]
174pub struct LIMIT<'a> {
175    pub offset: &'a [u8],
176    pub count: &'a [u8],
177}
178
179#[derive(Debug)]
180pub enum ORDER {
181    ASC,
182    DESC,
183}
184
185pub(crate) fn parse_sort(mut iter: Iter<Vec<u8>>) -> SORT {
186    let key = iter.next().unwrap();
187    let mut order = None;
188    let mut alpha = None;
189    let mut limit = None;
190    let mut destination = None;
191    let mut by_pattern = None;
192    let mut patterns = Vec::new();
193    let mut get_patterns = None;
194
195    while let Some(next_arg) = iter.next() {
196        let arg_upper = String::from_utf8_lossy(next_arg).to_uppercase();
197        if &arg_upper == "ASC" {
198            order = Some(ASC);
199        } else if &arg_upper == "DESC" {
200            order = Some(DESC);
201        } else if &arg_upper == "ALPHA" {
202            alpha = Some(true);
203        } else if &arg_upper == "LIMIT" {
204            let offset = iter.next().unwrap();
205            let count = iter.next().unwrap();
206            limit = Some(LIMIT { offset, count });
207        } else if &arg_upper == "STORE" {
208            let store = iter.next().unwrap();
209            destination = Some(store.as_slice());
210        } else if &arg_upper == "BY" {
211            let pattern = iter.next().unwrap();
212            by_pattern = Some(pattern.as_slice());
213        } else if &arg_upper == "GET" {
214            let next_pattern = iter.next().unwrap();
215            patterns.push(next_pattern.as_slice());
216        }
217    }
218    if !patterns.is_empty() {
219        get_patterns = Some(patterns);
220    }
221    SORT {
222        key,
223        by_pattern,
224        limit,
225        get_patterns,
226        order,
227        alpha,
228        destination,
229    }
230}
231
232#[derive(Debug)]
233pub struct UNLINK<'a> {
234    pub keys: Vec<&'a [u8]>,
235}
236
237pub(crate) fn parse_unlink(mut iter: Iter<Vec<u8>>) -> UNLINK {
238    let mut keys = Vec::new();
239    while let Some(next_key) = iter.next() {
240        keys.push(next_key.as_slice());
241    }
242    UNLINK { keys }
243}
redis_event/cmd/keys.rs

redis_event/cmd/
keys.rs
