1use super::*;
2use chrono::{DateTime, Utc};
3
4pub fn on_key(top: impl AsRef<[u8]>, on: u64, sep: Option<[u8; 1]>) -> Vec<u8> {
15 let top_bytes = top.as_ref();
16 let sep_bytes = sep.map_or(b".".to_vec(), |s| s.to_vec());
17
18 let mut result = Vec::with_capacity(top_bytes.len() + sep_bytes.len() + 32);
20 result.extend_from_slice(top_bytes);
21 result.extend_from_slice(sep_bytes.as_slice());
22
23 let hex_str = format!("{:032x}", on);
25 result.extend_from_slice(hex_str.as_bytes());
26
27 result
28}
29
30pub fn sn_key(pre: impl AsRef<[u8]>, sn: u64) -> Vec<u8> {
40 on_key(pre, sn, Some(*b"."))
41}
42
43pub fn fn_key(pre: impl AsRef<[u8]>, fn_val: u64) -> Vec<u8> {
53 on_key(pre, fn_val, Some(*b"."))
54}
55
56pub fn dg_key(pre: impl AsRef<[u8]>, dig: impl AsRef<[u8]>) -> Vec<u8> {
66 let pre_bytes = pre.as_ref();
67 let dig_bytes = dig.as_ref();
68
69 let mut result = Vec::with_capacity(pre_bytes.len() + 1 + dig_bytes.len());
70 result.extend_from_slice(pre_bytes);
71 result.push(b'.');
72 result.extend_from_slice(dig_bytes);
73
74 result
75}
76
77pub fn dt_key(pre: impl AsRef<[u8]>, dts: impl AsRef<[u8]>) -> Vec<u8> {
88 let pre_bytes = pre.as_ref();
89 let dts_bytes = dts.as_ref();
90
91 let mut result = Vec::with_capacity(pre_bytes.len() + 1 + dts_bytes.len());
92 result.extend_from_slice(pre_bytes);
93 result.push(b'|');
94 result.extend_from_slice(dts_bytes);
95
96 result
97}
98
99pub fn split_key(
112 key: impl AsRef<[u8]>,
113 sep: Option<[u8; 1]>,
114) -> Result<(Vec<u8>, Vec<u8>), DBError> {
115 let key_bytes = key.as_ref();
116 let sep_bytes = sep.map_or(b".".to_vec(), |s| s.to_vec());
117
118 if let Some(pos) = key_bytes.iter().rposition(|&b| b == sep_bytes[0]) {
119 if sep_bytes.len() == 1 || key_bytes[pos..pos + sep_bytes.len()] == sep_bytes[..] {
120 let (pre, suf) = key_bytes.split_at(pos);
121 let suf = &suf[sep_bytes.len()..];
123 return Ok((pre.to_vec(), suf.to_vec()));
124 }
125 }
126
127 Err(DBError::ValueError(format!(
128 "Unsplittable key at {:?}",
129 sep_bytes
130 )))
131}
132
133pub fn split_on_key(
146 key: impl AsRef<[u8]>,
147 sep: Option<[u8; 1]>,
148) -> Result<(Vec<u8>, u64), DBError> {
149 let (top, on_bytes) = split_key(key, sep)?;
150
151 let on_str = String::from_utf8(on_bytes)
153 .map_err(|e| DBError::ParseError(format!("Invalid UTF-8 in ordinal: {}", e)))?;
154
155 let on = u64::from_str_radix(&on_str, 16)
156 .map_err(|e| DBError::ParseError(format!("Invalid hex in ordinal {}: {}", on_str, e)))?;
157
158 Ok((top, on))
159}
160
161pub fn split_sn_key(
163 key: impl AsRef<[u8]>,
164 sep: Option<[u8; 1]>,
165) -> Result<(Vec<u8>, u64), DBError> {
166 split_on_key(key, sep)
167}
168
169pub fn split_fn_key(
170 key: impl AsRef<[u8]>,
171 sep: Option<[u8; 1]>,
172) -> Result<(Vec<u8>, u64), DBError> {
173 split_on_key(key, sep)
174}
175
176pub fn split_key_on(
178 key: impl AsRef<[u8]>,
179 sep: Option<[u8; 1]>,
180) -> Result<(Vec<u8>, u64), DBError> {
181 split_on_key(key, sep)
182}
183
184pub fn split_key_sn(
185 key: impl AsRef<[u8]>,
186 sep: Option<[u8; 1]>,
187) -> Result<(Vec<u8>, u64), DBError> {
188 split_on_key(key, sep)
189}
190
191pub fn split_key_fn(
192 key: impl AsRef<[u8]>,
193 sep: Option<[u8; 1]>,
194) -> Result<(Vec<u8>, u64), DBError> {
195 split_on_key(key, sep)
196}
197
198pub fn split_key_dt(key: impl AsRef<[u8]>) -> Result<(Vec<u8>, DateTime<Utc>), DBError> {
210 let (pre, dts_bytes) = split_key(key, Some(*b"|"))?;
211
212 let dts = String::from_utf8(dts_bytes)
214 .map_err(|e| DBError::ParseError(format!("Invalid UTF-8 in datetime: {}", e)))?;
215
216 let dt = DateTime::parse_from_rfc3339(&dts)
218 .map_err(|e| DBError::ParseError(format!("Invalid datetime format: {}", e)))?
219 .with_timezone(&Utc);
220
221 Ok((pre, dt))
222}
223
224pub fn suffix(key: impl AsRef<[u8]>, ion: u64, sep: Option<[u8; 1]>) -> Vec<u8> {
237 let key_bytes = key.as_ref();
238 let sep_bytes = sep.map_or(b".".to_vec(), |s| s.to_vec());
239
240 let ion_str = format!("{:032x}", ion);
242
243 let mut result = Vec::with_capacity(key_bytes.len() + sep_bytes.len() + 32);
245 result.extend_from_slice(key_bytes);
246 result.extend_from_slice(sep_bytes.as_slice());
247 result.extend_from_slice(ion_str.as_bytes());
248
249 result
250}
251
252pub fn unsuffix(iokey: impl AsRef<[u8]>, sep: Option<[u8; 1]>) -> Result<(Vec<u8>, u64), DBError> {
265 let iokey_bytes = iokey.as_ref();
266 let sep_bytes = sep.map_or(b".".to_vec(), |s| s.to_vec());
267
268 if let Some(pos) = iokey_bytes
270 .windows(sep_bytes.len())
271 .rposition(|window| window == sep_bytes)
272 {
273 let (key, ion_with_sep) = iokey_bytes.split_at(pos);
274 let ion_bytes = &ion_with_sep[sep_bytes.len()..];
275
276 let ion_str = String::from_utf8(ion_bytes.to_vec())
278 .map_err(|e| DBError::ParseError(format!("Invalid UTF-8 in ion: {}", e)))?;
279
280 let ion = u64::from_str_radix(&ion_str, 16)
281 .map_err(|e| DBError::ParseError(format!("Invalid hex in ion: {}", e)))?;
282
283 return Ok((key.to_vec(), ion));
284 }
285
286 Err(DBError::ValueError(format!(
287 "Unsplittable iokey at {:?}",
288 sep_bytes
289 )))
290}
291
292#[cfg(test)]
293mod tests {
294 use super::*;
295 use chrono::{DateTime, Utc};
296
297 #[test]
298 fn test_key_funcs() {
299 let pre = b"BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc".to_vec();
301 let dig = b"EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4".to_vec();
302 let sn = 3;
303 let dts = b"2021-02-13T19:16:50.750302+00:00".to_vec();
304
305 assert_eq!(
307 on_key(&pre, 0, None),
308 [
309 pre.as_slice(),
310 b".00000000000000000000000000000000".as_slice()
311 ]
312 .concat()
313 );
314 assert_eq!(
315 on_key(&pre, 1, None),
316 [
317 pre.as_slice(),
318 b".00000000000000000000000000000001".as_slice()
319 ]
320 .concat()
321 );
322 assert_eq!(
323 on_key(&pre, 2, None),
324 [
325 pre.as_slice(),
326 b".00000000000000000000000000000002".as_slice()
327 ]
328 .concat()
329 );
330 assert_eq!(
331 on_key(&pre, 3, None),
332 [
333 pre.as_slice(),
334 b".00000000000000000000000000000003".as_slice()
335 ]
336 .concat()
337 );
338 assert_eq!(
339 on_key(&pre, 4, None),
340 [
341 pre.as_slice(),
342 b".00000000000000000000000000000004".as_slice()
343 ]
344 .concat()
345 );
346
347 assert_eq!(
348 on_key(&pre, 0, Some(*b"|")),
349 [
350 pre.as_slice(),
351 b"|00000000000000000000000000000000".as_slice()
352 ]
353 .concat()
354 );
355 assert_eq!(
356 on_key(&pre, 4, Some(*b"|")),
357 [
358 pre.as_slice(),
359 b"|00000000000000000000000000000004".as_slice()
360 ]
361 .concat()
362 );
363
364 let onkey = on_key(&pre, 0, None);
365 assert_eq!(
366 split_key(&onkey, None).unwrap(),
367 (pre.clone(), format!("{:032x}", 0).as_bytes().to_vec())
368 );
369 assert_eq!(split_on_key(&onkey, None).unwrap(), (pre.clone(), 0));
370
371 let onkey = on_key(&pre, 1, None);
372 assert_eq!(
373 split_key(&onkey, None).unwrap(),
374 (pre.clone(), format!("{:032x}", 1).as_bytes().to_vec())
375 );
376 assert_eq!(split_on_key(&onkey, None).unwrap(), (pre.clone(), 1));
377
378 let onkey = on_key(&pre, 15, None);
379 assert_eq!(
380 split_key(&onkey, None).unwrap(),
381 (pre.clone(), format!("{:032x}", 15).as_bytes().to_vec())
382 );
383 assert_eq!(split_on_key(&onkey, None).unwrap(), (pre.clone(), 15));
384
385 let onkey = on_key(&pre, 0, Some(*b"|"));
386 assert_eq!(
387 split_key(&onkey, Some(*b"|")).unwrap(),
388 (pre.clone(), format!("{:032x}", 0).as_bytes().to_vec())
389 );
390 assert_eq!(split_on_key(&onkey, Some(*b"|")).unwrap(), (pre.clone(), 0));
391
392 let onkey = on_key(&pre, 15, Some(*b"|"));
393 assert_eq!(
394 split_key(&onkey, Some(*b"|")).unwrap(),
395 (pre.clone(), format!("{:032x}", 15).as_bytes().to_vec())
396 );
397 assert_eq!(
398 split_on_key(&onkey, Some(*b"|")).unwrap(),
399 (pre.clone(), 15)
400 );
401
402 assert_eq!(
404 sn_key(&pre, sn),
405 b"BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc.00000000000000000000000000000003"
406 .to_vec()
407 );
408
409 assert_eq!(
410 split_key(&sn_key(&pre, sn), None).unwrap(),
411 (pre.clone(), format!("{:032x}", sn).as_bytes().to_vec())
412 );
413 assert_eq!(
414 split_sn_key(&sn_key(&pre, sn), None).unwrap(),
415 (pre.clone(), sn)
416 );
417
418 assert_eq!(
419 dg_key(&pre, &dig),
420 b"BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4".to_vec()
421 );
422
423 assert_eq!(
424 split_key(&dg_key(&pre, &dig), None).unwrap(),
425 (pre.clone(), dig.clone())
426 );
427
428 assert_eq!(
429 dt_key(&pre, &dts),
430 b"BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc|2021-02-13T19:16:50.750302+00:00"
431 .to_vec()
432 );
433
434 assert_eq!(
435 split_key(&dt_key(&pre, &dts), Some(*b"|")).unwrap(),
436 (pre.clone(), dts.clone())
437 );
438
439 let datetime = DateTime::parse_from_rfc3339("2021-02-13T19:16:50.750302+00:00")
441 .unwrap()
442 .with_timezone(&Utc);
443 assert_eq!(split_key_dt(&dt_key(&pre, &dts)).unwrap().0, pre.clone());
444 let pre_str = "BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc";
449 let dig_str = "EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4";
450 let dts_str = "2021-02-13T19:16:50.750302+00:00";
451
452 assert_eq!(
453 sn_key(pre_str, sn),
454 b"BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc.00000000000000000000000000000003"
455 .to_vec()
456 );
457
458 let sn_key_str = String::from_utf8(sn_key(pre_str, sn)).unwrap();
459 assert_eq!(
460 split_key(&sn_key_str, None).unwrap(),
461 (
462 pre_str.as_bytes().to_vec(),
463 format!("{:032x}", sn).as_bytes().to_vec()
464 )
465 );
466 assert_eq!(
467 split_sn_key(&sn_key_str, None).unwrap(),
468 (pre_str.as_bytes().to_vec(), sn)
469 );
470
471 assert_eq!(
472 dg_key(pre_str, dig_str),
473 b"BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4".to_vec()
474 );
475
476 let dg_key_str = String::from_utf8(dg_key(pre_str, dig_str)).unwrap();
477 assert_eq!(
478 split_key(&dg_key_str, None).unwrap(),
479 (pre_str.as_bytes().to_vec(), dig_str.as_bytes().to_vec())
480 );
481
482 assert_eq!(
483 dt_key(pre_str, dts_str),
484 b"BAzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc|2021-02-13T19:16:50.750302+00:00"
485 .to_vec()
486 );
487
488 let dt_key_str = String::from_utf8(dt_key(pre_str, dts_str)).unwrap();
489 assert_eq!(
490 split_key(&dt_key_str, Some(*b"|")).unwrap(),
491 (pre_str.as_bytes().to_vec(), dts_str.as_bytes().to_vec())
492 );
493
494 let datetime_str = DateTime::parse_from_rfc3339(dts_str)
495 .unwrap()
496 .with_timezone(&Utc);
497 assert_eq!(
498 split_key_dt(&dt_key_str).unwrap().0,
499 pre_str.as_bytes().to_vec()
500 );
501
502 let result = split_key(pre.as_slice(), None);
508 assert!(result.is_err());
509
510 let nested_key = dg_key(&pre, &dg_key(&pre, &dig));
512 let (_, _) = split_key(&nested_key, None).unwrap();
513 }
514
515 #[test]
516 fn test_suffix() {
517 const SUFFIX_SIZE: usize = 32;
518 const MAX_SUFFIX: u128 = u128::MAX;
519
520 assert_eq!(SUFFIX_SIZE, 32);
522 assert_eq!(MAX_SUFFIX, 340282366920938463463374607431768211455);
523
524 let key = "ABCDEFG.FFFFFF";
525 let keyb = b"ABCDEFG.FFFFFF";
526
527 let ion = 0;
528 let iokey = suffix(key, ion, None);
529 assert_eq!(
530 iokey,
531 b"ABCDEFG.FFFFFF.00000000000000000000000000000000".to_vec()
532 );
533 let (k, i) = unsuffix(&iokey, None).unwrap();
534 assert_eq!(k, keyb.to_vec());
535 assert_eq!(i, ion);
536
537 let ion = 64;
538 let iokey = suffix(keyb, ion, None);
539 assert_eq!(
540 iokey,
541 b"ABCDEFG.FFFFFF.00000000000000000000000000000040".to_vec()
542 );
543 let (k, i) = unsuffix(&iokey, None).unwrap();
544 assert_eq!(k, keyb.to_vec());
545 assert_eq!(i, ion);
546
547 let iokey = suffix(key, MAX_SUFFIX as u64, None);
548 println!("{}", String::from_utf8_lossy(&iokey));
549
550 let (k, i) = unsuffix(&iokey, None).unwrap();
553 assert_eq!(k, keyb.to_vec());
554 assert_eq!(i, MAX_SUFFIX as u64);
555 }
556}