···

       
29
       
 
       


     

       
30
       
 
       
result

     

       
31
       
 
       
server/bsky_zstd_dictionary

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
29
       
 
       


     

       
30
       
 
       
result

     

       
31
       
 
       
server/bsky_zstd_dictionary

     

       
32
       
+
       
fjall_data*

     

       
33
       
+
       
.fjall_data*

     

···

       
183
       
 
       


     

       
184
       
 
       
    for maybe_hit in maybe_hits {

     

       
185
       
 
       
        let hit = maybe_hit?;

     

       
186
       
-
       
        let hit_data = hit.access();

     

       
187
       
 
       


     

       
188
       
 
       
        hits.push(Hit {

     

       
189
       
 
       
            timestamp: hit.timestamp,

     

···

       
183
       
 
       


     

       
184
       
 
       
    for maybe_hit in maybe_hits {

     

       
185
       
 
       
        let hit = maybe_hit?;

     

       
186
       
+
       
        let hit_data = hit.deser()?;

     

       
187
       
 
       


     

       
188
       
 
       
        hits.push(Hit {

     

       
189
       
 
       
            timestamp: hit.timestamp,

     

···

       
5
       
 
       
};

     

       
6
       
 
       


     

       
7
       
 
       
use rkyv::{

     

       
8
       
-
       
    Archive, Serialize, api::high::HighSerializer, rancor, ser::allocator::ArenaHandle,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
9
       
 
       
    util::AlignedVec,

     

       
10
       
 
       
};

     

       
11
       
 
       


     

       
12
       
-
       
use crate::utils::{ReadVariableExt, WriteVariableExt};

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
13
       
 
       


     

       
14
       
 
       
pub struct Item<T> {

     

       
15
       
 
       
    pub timestamp: u64,

     

       
16
       
-
       
    data: AlignedVec,

     

       
17
       
 
       
    phantom: PhantomData<T>,

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
-
       
impl<T: Archive> Item<T> {

     

       
21
       
-
       
    pub fn access(&self) -> &T::Archived {

     

       
22
       
-
       
        unsafe { rkyv::access_unchecked::<T::Archived>(&self.data) }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
23
       
 
       
    }

     

       
24
       
 
       
}

     

       
25
       
 
       


     
···

       
248
       
 
       
        let decoded_item = decoder.decode().unwrap().unwrap();

     

       
249
       
 
       
        assert_eq!(decoded_item.timestamp, 1000);

     

       
250
       
 
       


     

       
251
       
-
       
        let decoded_data = decoded_item.access();

     

       
252
       
 
       
        assert_eq!(decoded_data.id, 123);

     

       
253
       
 
       
        assert_eq!(decoded_data.value.as_str(), "test");

     

       
254
       
 
       
    }

     
···

       
308
       
 
       


     

       
309
       
 
       
        for (original, decoded) in items.iter().zip(decoded_items.iter()) {

     

       
310
       
 
       
            assert_eq!(original.timestamp, decoded.timestamp);

     

       
311
       
-
       
            assert_eq!(original.access().id, decoded.access().id);

     

       
312
       
 
       
            assert_eq!(

     

       
313
       
-
       
                original.access().value.as_str(),

     

       
314
       
-
       
                decoded.access().value.as_str()

     

       
315
       
 
       
            );

     

       
316
       
 
       
        }

     

       
317
       
 
       
    }

     
···

       
363
       
 
       
        assert_eq!(decoded_items[1].timestamp, 2005);

     

       
364
       
 
       
        assert_eq!(decoded_items[2].timestamp, 2012);

     

       
365
       
 
       


     

       
366
       
-
       
        assert_eq!(decoded_items[0].access().id, 10);

     

       
367
       
-
       
        assert_eq!(decoded_items[1].access().id, 20);

     

       
368
       
-
       
        assert_eq!(decoded_items[2].access().id, 30);

     

       
369
       
 
       
    }

     

       
370
       
 
       


     

       
371
       
 
       
    #[test]

     
···

       
418
       
 
       


     

       
419
       
 
       
        for (original, decoded) in items.iter().zip(decoded_items.iter()) {

     

       
420
       
 
       
            assert_eq!(original.timestamp, decoded.timestamp);

     

       
421
       
-
       
            assert_eq!(original.access().id, decoded.access().id);

     

       
422
       
 
       
        }

     

       
423
       
 
       
    }

     

       
424
       
 
       


     
···

       
498
       
 
       
        let decoded_items = decoded_items.unwrap();

     

       
499
       
 
       


     

       
500
       
 
       
        assert_eq!(decoded_items.len(), 2);

     

       
501
       
-
       
        assert_eq!(decoded_items[0].access().value.as_str(), "x");

     

       
502
       
-
       
        assert_eq!(decoded_items[1].access().value.len(), 1000);

     

       
503
       
-
       
        assert_eq!(decoded_items[1].access().value.as_str(), "a".repeat(1000));

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
504
       
 
       
    }

     

       
505
       
 
       
}

     

···

       
5
       
 
       
};

     

       
6
       
 
       


     

       
7
       
 
       
use rkyv::{

     

       
8
       
+
       
    Archive, Deserialize, Serialize,

     

       
9
       
+
       
    api::high::{HighSerializer, HighValidator},

     

       
10
       
+
       
    bytecheck::CheckBytes,

     

       
11
       
+
       
    de::Pool,

     

       
12
       
+
       
    rancor::{self, Strategy},

     

       
13
       
+
       
    ser::allocator::ArenaHandle,

     

       
14
       
 
       
    util::AlignedVec,

     

       
15
       
 
       
};

     

       
16
       
 
       


     

       
17
       
+
       
use crate::{

     

       
18
       
+
       
    error::{AppError, AppResult},

     

       
19
       
+
       
    utils::{ReadVariableExt, WriteVariableExt},

     

       
20
       
+
       
};

     

       
21
       
 
       


     

       
22
       
 
       
pub struct Item<T> {

     

       
23
       
 
       
    pub timestamp: u64,

     

       
24
       
+
       
    pub data: AlignedVec,

     

       
25
       
 
       
    phantom: PhantomData<T>,

     

       
26
       
 
       
}

     

       
27
       
 
       


     

       
28
       
+
       
impl<T> Item<T>

     

       
29
       
+
       
where

     

       
30
       
+
       
    T: Archive,

     

       
31
       
+
       
    T::Archived: for<'a> CheckBytes<HighValidator<'a, rancor::Error>>

     

       
32
       
+
       
        + Deserialize<T, Strategy<Pool, rancor::Error>>,

     

       
33
       
+
       
{

     

       
34
       
+
       
    pub fn deser(&self) -> AppResult<T> {

     

       
35
       
+
       
        rkyv::from_bytes(&self.data).map_err(AppError::from)

     

       
36
       
 
       
    }

     

       
37
       
 
       
}

     

       
38
       
 
       


     
···

       
261
       
 
       
        let decoded_item = decoder.decode().unwrap().unwrap();

     

       
262
       
 
       
        assert_eq!(decoded_item.timestamp, 1000);

     

       
263
       
 
       


     

       
264
       
+
       
        let decoded_data = decoded_item.deser().unwrap();

     

       
265
       
 
       
        assert_eq!(decoded_data.id, 123);

     

       
266
       
 
       
        assert_eq!(decoded_data.value.as_str(), "test");

     

       
267
       
 
       
    }

     
···

       
321
       
 
       


     

       
322
       
 
       
        for (original, decoded) in items.iter().zip(decoded_items.iter()) {

     

       
323
       
 
       
            assert_eq!(original.timestamp, decoded.timestamp);

     

       
324
       
+
       
            assert_eq!(original.deser().unwrap().id, decoded.deser().unwrap().id);

     

       
325
       
 
       
            assert_eq!(

     

       
326
       
+
       
                original.deser().unwrap().value.as_str(),

     

       
327
       
+
       
                decoded.deser().unwrap().value.as_str()

     

       
328
       
 
       
            );

     

       
329
       
 
       
        }

     

       
330
       
 
       
    }

     
···

       
376
       
 
       
        assert_eq!(decoded_items[1].timestamp, 2005);

     

       
377
       
 
       
        assert_eq!(decoded_items[2].timestamp, 2012);

     

       
378
       
 
       


     

       
379
       
+
       
        assert_eq!(decoded_items[0].deser().unwrap().id, 10);

     

       
380
       
+
       
        assert_eq!(decoded_items[1].deser().unwrap().id, 20);

     

       
381
       
+
       
        assert_eq!(decoded_items[2].deser().unwrap().id, 30);

     

       
382
       
 
       
    }

     

       
383
       
 
       


     

       
384
       
 
       
    #[test]

     
···

       
431
       
 
       


     

       
432
       
 
       
        for (original, decoded) in items.iter().zip(decoded_items.iter()) {

     

       
433
       
 
       
            assert_eq!(original.timestamp, decoded.timestamp);

     

       
434
       
+
       
            assert_eq!(original.deser().unwrap().id, decoded.deser().unwrap().id);

     

       
435
       
 
       
        }

     

       
436
       
 
       
    }

     

       
437
       
 
       


     
···

       
511
       
 
       
        let decoded_items = decoded_items.unwrap();

     

       
512
       
 
       


     

       
513
       
 
       
        assert_eq!(decoded_items.len(), 2);

     

       
514
       
+
       
        assert_eq!(decoded_items[0].deser().unwrap().value.as_str(), "x");

     

       
515
       
+
       
        assert_eq!(decoded_items[1].deser().unwrap().value.len(), 1000);

     

       
516
       
+
       
        assert_eq!(

     

       
517
       
+
       
            decoded_items[1].deser().unwrap().value.as_str(),

     

       
518
       
+
       
            "a".repeat(1000)

     

       
519
       
+
       
        );

     

       
520
       
 
       
    }

     

       
521
       
 
       
}

     

···

       
291
       
 
       
                    EventRecord {

     

       
292
       
 
       
                        nsid: nsid.to_smolstr(),

     

       
293
       
 
       
                        timestamp: hit.timestamp,

     

       
294
       
-
       
                        deleted: hit.access().deleted,

     

       
295
       
 
       
                    }

     

       
296
       
 
       
                }))

     

       
297
       
 
       
                .expect("cant record event");

     

···

       
291
       
 
       
                    EventRecord {

     

       
292
       
 
       
                        nsid: nsid.to_smolstr(),

     

       
293
       
 
       
                        timestamp: hit.timestamp,

     

       
294
       
+
       
                        deleted: hit.deser().unwrap().deleted,

     

       
295
       
 
       
                    }

     

       
296
       
 
       
                }))

     

       
297
       
 
       
                .expect("cant record event");