fast_cache/storage/embedded_store_sharded/
read.rs

1use super::*;
2
3impl WorkerLocalEmbeddedStore {
4    pub fn get(&mut self, key: &[u8]) -> Option<Bytes> {
5        self.get_if_local(key)
6            .expect("worker-local embedded store key does not belong to this thread")
7    }
8
9    pub fn get_if_local(&mut self, key: &[u8]) -> Result<Option<Bytes>, LocalRouteError> {
10        self.local_key_route(key)?;
11        Ok(self.inner.local_get(key))
12    }
13
14    pub fn get_view<'a>(&'a mut self, key: &[u8]) -> WorkerLocalReadView<'a> {
15        self.get_view_if_local(key)
16            .expect("worker-local embedded store key does not belong to this thread")
17    }
18
19    #[inline(always)]
20    pub fn get_owned_view_local(&mut self, key: &[u8]) -> OwnedEmbeddedReadView {
21        self.inner.get_view(key)
22    }
23
24    pub fn get_view_if_local<'a>(
25        &'a mut self,
26        key: &[u8],
27    ) -> Result<WorkerLocalReadView<'a>, LocalRouteError> {
28        let route = self.local_key_route(key)?;
29        Ok(WorkerLocalReadView {
30            item: self
31                .inner
32                .local_get_slice_routed(route, key)
33                .map(WorkerLocalReadSlice::from_embedded),
34        })
35    }
36
37    #[inline(always)]
38    pub fn get_view_routed_local<'a>(
39        &'a mut self,
40        route: EmbeddedKeyRoute,
41        key: &[u8],
42    ) -> WorkerLocalReadView<'a> {
43        debug_assert!(self.owns_shard(route.shard_id));
44        WorkerLocalReadView {
45            item: self
46                .inner
47                .local_get_slice_routed(route, key)
48                .map(WorkerLocalReadSlice::from_embedded),
49        }
50    }
51
52    #[inline(always)]
53    pub fn get_view_routed_no_ttl<'a>(
54        &'a mut self,
55        route: EmbeddedKeyRoute,
56        key: &[u8],
57    ) -> WorkerLocalReadView<'a> {
58        self.get_view_routed_no_ttl_local(route, key)
59    }
60
61    #[inline(always)]
62    pub fn get_view_routed_no_ttl_if_local<'a>(
63        &'a mut self,
64        route: EmbeddedKeyRoute,
65        key: &[u8],
66    ) -> Result<WorkerLocalReadView<'a>, LocalRouteError> {
67        self.ensure_local_route(route)?;
68        Ok(WorkerLocalReadView {
69            item: self
70                .inner
71                .local_get_slice_routed_no_ttl(route, key)
72                .map(WorkerLocalReadSlice::from_embedded),
73        })
74    }
75
76    #[inline(always)]
77    pub fn get_point_view_routed_no_ttl_local<'a>(
78        &'a mut self,
79        route: EmbeddedKeyRoute,
80        key: &[u8],
81    ) -> WorkerLocalReadView<'a> {
82        debug_assert!(self.owns_shard(route.shard_id));
83        WorkerLocalReadView {
84            item: self
85                .inner
86                .local_get_point_ref_routed_no_ttl(route, key)
87                .map(WorkerLocalReadSlice::from_local_slice),
88        }
89    }
90
91    #[inline(always)]
92    pub fn get_point_ref_routed_no_ttl_local<'a>(
93        &'a mut self,
94        route: EmbeddedKeyRoute,
95        key: &[u8],
96    ) -> Option<&'a [u8]> {
97        debug_assert!(self.owns_shard(route.shard_id));
98        self.inner.local_get_point_ref_routed_no_ttl(route, key)
99    }
100
101    #[inline(always)]
102    pub fn get_prepared_point_view_no_ttl_local<'a>(
103        &'a mut self,
104        prepared: &PreparedPointKey,
105    ) -> WorkerLocalReadView<'a> {
106        debug_assert!(self.owns_shard(prepared.route().shard_id));
107        WorkerLocalReadView {
108            item: self
109                .inner
110                .local_get_point_ref_prepared_routed_no_ttl(prepared)
111                .map(WorkerLocalReadSlice::from_local_slice),
112        }
113    }
114
115    #[inline(always)]
116    pub fn get_prepared_point_ref_no_ttl_local<'a>(
117        &'a mut self,
118        prepared: &PreparedPointKey,
119    ) -> Option<&'a [u8]> {
120        debug_assert!(self.owns_shard(prepared.route().shard_id));
121        self.inner
122            .local_get_point_ref_prepared_routed_no_ttl(prepared)
123    }
124
125    #[inline(always)]
126    pub fn get_view_routed_no_ttl_local<'a>(
127        &'a mut self,
128        route: EmbeddedKeyRoute,
129        key: &[u8],
130    ) -> WorkerLocalReadView<'a> {
131        debug_assert!(self.owns_shard(route.shard_id));
132        WorkerLocalReadView {
133            item: self
134                .inner
135                .local_get_ref_routed_no_ttl(route, key)
136                .map(WorkerLocalReadSlice::from_local_slice),
137        }
138    }
139
140    #[inline(always)]
141    pub fn get_ref_routed_no_ttl_if_local<'a>(
142        &'a mut self,
143        route: EmbeddedKeyRoute,
144        key: &[u8],
145    ) -> Result<Option<&'a [u8]>, LocalRouteError> {
146        self.ensure_local_route(route)?;
147        Ok(self.inner.local_get_ref_routed_no_ttl(route, key))
148    }
149
150    #[inline(always)]
151    pub fn get_ref_routed_no_ttl_local<'a>(
152        &'a mut self,
153        route: EmbeddedKeyRoute,
154        key: &[u8],
155    ) -> Option<&'a [u8]> {
156        debug_assert!(self.owns_shard(route.shard_id));
157        self.inner.local_get_ref_routed_no_ttl(route, key)
158    }
159
160    pub fn batch_get(&mut self, keys: Vec<Bytes>) -> Vec<Option<Bytes>> {
161        self.batch_get_if_local(keys)
162            .expect("worker-local embedded store batch includes keys owned by another thread")
163    }
164
165    pub fn batch_get_if_local(
166        &mut self,
167        keys: Vec<Bytes>,
168    ) -> Result<Vec<Option<Bytes>>, LocalRouteError> {
169        self.ensure_local_keys(&keys)?;
170        Ok(keys
171            .into_iter()
172            .map(|key| self.inner.local_get(&key))
173            .collect::<Vec<_>>())
174    }
175
176    pub fn batch_get_view<'a>(&'a mut self, keys: &[Bytes]) -> WorkerLocalBatchReadView<'a> {
177        self.batch_get_view_if_local(keys)
178            .expect("worker-local embedded store batch includes keys owned by another thread")
179    }
180
181    #[inline(always)]
182    pub fn batch_get_owned_view_local(&mut self, keys: &[Bytes]) -> OwnedEmbeddedBatchReadView {
183        self.inner.batch_get_view(keys)
184    }
185
186    pub fn batch_get_view_if_local<'a>(
187        &'a mut self,
188        keys: &[Bytes],
189    ) -> Result<WorkerLocalBatchReadView<'a>, LocalRouteError> {
190        self.ensure_local_keys(keys)?;
191        Ok(worker_local_batch_view_from_embedded(
192            self.inner.local_batch_get_slices(keys),
193        ))
194    }
195
196    pub fn batch_get_session_view<'a>(
197        &'a mut self,
198        session_prefix: &[u8],
199        keys: &[Bytes],
200    ) -> WorkerLocalSessionBatchView<'a> {
201        self.batch_get_session_view_if_local(session_prefix, keys)
202            .expect("worker-local embedded store session does not belong to this thread")
203    }
204
205    pub fn batch_get_session_view_if_local<'a>(
206        &'a mut self,
207        session_prefix: &[u8],
208        keys: &[Bytes],
209    ) -> Result<WorkerLocalSessionBatchView<'a>, LocalRouteError> {
210        let key_hashes = keys
211            .iter()
212            .map(|key| crate::storage::hash_key(key))
213            .collect::<Vec<_>>();
214        self.batch_get_session_view_prehashed_if_local(session_prefix, keys, &key_hashes)
215    }
216
217    #[inline(always)]
218    pub fn batch_get_session_owned_view_local(
219        &mut self,
220        session_prefix: &[u8],
221        keys: &[Bytes],
222    ) -> OwnedEmbeddedBatchReadView {
223        self.inner.batch_get_session_view(session_prefix, keys)
224    }
225
226    pub fn batch_get_session_view_prehashed_if_local<'a>(
227        &'a mut self,
228        session_prefix: &[u8],
229        keys: &[Bytes],
230        key_hashes: &[u64],
231    ) -> Result<WorkerLocalSessionBatchView<'a>, LocalRouteError> {
232        self.local_session_route(session_prefix)?;
233        Ok(worker_local_batch_view_from_embedded(
234            self.inner
235                .local_batch_get_session_slices_prehashed(session_prefix, keys, key_hashes),
236        ))
237    }
238
239    #[inline(always)]
240    pub fn batch_get_session_owned_view_prehashed_local(
241        &mut self,
242        session_prefix: &[u8],
243        keys: &[Bytes],
244        key_hashes: &[u64],
245    ) -> OwnedEmbeddedBatchReadView {
246        self.inner
247            .batch_get_session_view_prehashed(session_prefix, keys, key_hashes)
248    }
249
250    pub fn batch_get_session_packed(
251        &mut self,
252        session_prefix: &[u8],
253        keys: &[Bytes],
254    ) -> PackedBatch {
255        self.batch_get_session_packed_if_local(session_prefix, keys)
256            .expect("worker-local embedded store session does not belong to this thread")
257    }
258
259    pub fn batch_get_session_packed_if_local(
260        &mut self,
261        session_prefix: &[u8],
262        keys: &[Bytes],
263    ) -> Result<PackedBatch, LocalRouteError> {
264        self.local_session_route(session_prefix)?;
265        Ok(self.inner.batch_get_session_packed(session_prefix, keys))
266    }
267
268    pub fn batch_get_session_packed_view(
269        &mut self,
270        session_prefix: &[u8],
271        keys: &[Bytes],
272    ) -> Option<OwnedEmbeddedSessionPackedView> {
273        self.batch_get_session_packed_view_if_local(session_prefix, keys)
274            .expect("worker-local embedded store session does not belong to this thread")
275    }
276
277    pub fn batch_get_session_packed_view_if_local(
278        &mut self,
279        session_prefix: &[u8],
280        keys: &[Bytes],
281    ) -> Result<Option<OwnedEmbeddedSessionPackedView>, LocalRouteError> {
282        let key_hashes = keys
283            .iter()
284            .map(|key| crate::storage::hash_key(key))
285            .collect::<Vec<_>>();
286        self.batch_get_session_packed_view_prehashed_if_local(session_prefix, keys, &key_hashes)
287    }
288
289    pub fn batch_get_session_packed_view_prehashed_if_local(
290        &mut self,
291        session_prefix: &[u8],
292        keys: &[Bytes],
293        key_hashes: &[u64],
294    ) -> Result<Option<OwnedEmbeddedSessionPackedView>, LocalRouteError> {
295        self.local_session_route(session_prefix)?;
296        Ok(self
297            .inner
298            .batch_get_session_packed_view_prehashed(session_prefix, keys, key_hashes))
299    }
300
301    pub fn batch_get_packed(&mut self, keys: &[Bytes]) -> PackedBatch {
302        self.batch_get_packed_if_local(keys)
303            .expect("worker-local embedded store batch includes keys owned by another thread")
304    }
305
306    pub fn batch_get_packed_if_local(
307        &mut self,
308        keys: &[Bytes],
309    ) -> Result<PackedBatch, LocalRouteError> {
310        self.ensure_local_keys(keys)?;
311        Ok(self.inner.batch_get_packed(keys))
312    }
313}
fast_cache/storage/embedded_store_sharded/read.rs

fast_cache/storage/embedded_store_sharded/
read.rs
