aly.codes / microcosm-rs
Constellation, Spacedust, Slingshot, UFOs: atproto crates and services for microcosm
0
Fork 0

Configure Feed

Select the types of activity you want to include in your feed.

implement top collections over arbitrary times

phil (May 28, 2025, 8:58 PM EDT) 91baf420 31ac134e

+225 -235
+1 -76
ufos/src/server.rs
··· 284 284 method = GET, 285 285 path = "/collections" 286 286 }] 287 - /// Get a list of collection NSIDs with statistics 287 + /// Get collection with statistics 288 288 /// 289 289 /// ## To fetch a full list: 290 290 /// ··· 356 356 }) 357 357 } 358 358 359 - #[derive(Debug, Deserialize, JsonSchema)] 360 - struct TopByQuery { 361 - /// The maximum number of collections to return in one request. 362 - /// 363 - /// Default: 32 364 - #[schemars(range(min = 1, max = 200), default = "top_collections_default_limit")] 365 - #[serde(default = "top_collections_default_limit")] 366 - limit: usize, 367 - /// Limit collections and statistics to those seen after this UTC datetime 368 - since: Option<DateTime<Utc>>, 369 - /// Limit collections and statistics to those seen before this UTC datetime 370 - until: Option<DateTime<Utc>>, 371 - } 372 - fn top_collections_default_limit() -> usize { 373 - 32 374 - } 375 - 376 - /// Get top collections by record count 377 - #[endpoint { 378 - method = GET, 379 - path = "/collections/by-count" 380 - }] 381 - async fn get_top_collections_by_count( 382 - ctx: RequestContext<Context>, 383 - query: Query<TopByQuery>, 384 - ) -> OkCorsResponse<Vec<NsidCount>> { 385 - let Context { storage, .. } = ctx.context(); 386 - let q = query.into_inner(); 387 - 388 - if !(1..=200).contains(&q.limit) { 389 - let msg = format!("limit not in 1..=200: {}", q.limit); 390 - return Err(HttpError::for_bad_request(None, msg)); 391 - } 392 - 393 - let since = q.since.map(dt_to_cursor).transpose()?; 394 - let until = q.until.map(dt_to_cursor).transpose()?; 395 - 396 - let collections = storage 397 - .get_top_collections_by_count(100, since, until) 398 - .await 399 - .map_err(|e| HttpError::for_internal_error(format!("oh shoot: {e:?}")))?; 400 - 401 - ok_cors(collections) 402 - } 403 - 404 - /// Get top collections by estimated unique DIDs 405 - #[endpoint { 406 - method = GET, 407 - path = "/collections/by-dids" 408 - }] 409 - async fn get_top_collections_by_dids( 410 - ctx: RequestContext<Context>, 411 - query: Query<TopByQuery>, 412 - ) -> OkCorsResponse<Vec<NsidCount>> { 413 - let Context { storage, .. } = ctx.context(); 414 - let q = query.into_inner(); 415 - 416 - if !(1..=200).contains(&q.limit) { 417 - let msg = format!("limit not in 1..=200: {}", q.limit); 418 - return Err(HttpError::for_bad_request(None, msg)); 419 - } 420 - 421 - let since = q.since.map(dt_to_cursor).transpose()?; 422 - let until = q.until.map(dt_to_cursor).transpose()?; 423 - 424 - let collections = storage 425 - .get_top_collections_by_dids(100, since, until) 426 - .await 427 - .map_err(|e| HttpError::for_internal_error(format!("oh shoot: {e:?}")))?; 428 - 429 - ok_cors(collections) 430 - } 431 - 432 359 pub async fn serve(storage: impl StoreReader + 'static) -> Result<(), String> { 433 360 let log = ConfigLogging::StderrTerminal { 434 361 level: ConfigLoggingLevel::Info, ··· 444 371 api.register(get_records_by_collections).unwrap(); 445 372 api.register(get_records_total_seen).unwrap(); 446 373 api.register(get_collections).unwrap(); 447 - api.register(get_top_collections_by_count).unwrap(); 448 - api.register(get_top_collections_by_dids).unwrap(); 449 374 450 375 let context = Context { 451 376 spec: Arc::new(
-14
ufos/src/storage.rs
··· 84 84 until: Option<HourTruncatedCursor>, 85 85 ) -> StorageResult<(Vec<NsidCount>, Option<Vec<u8>>)>; 86 86 87 - async fn get_top_collections_by_count( 88 - &self, 89 - limit: usize, 90 - since: Option<HourTruncatedCursor>, 91 - until: Option<HourTruncatedCursor>, 92 - ) -> StorageResult<Vec<NsidCount>>; 93 - 94 - async fn get_top_collections_by_dids( 95 - &self, 96 - limit: usize, 97 - since: Option<HourTruncatedCursor>, 98 - until: Option<HourTruncatedCursor>, 99 - ) -> StorageResult<Vec<NsidCount>>; 100 - 101 87 async fn get_counts_by_collection(&self, collection: &Nsid) -> StorageResult<(u64, u64)>; 102 88 103 89 async fn get_records_by_collections(
+187 -129
ufos/src/storage_fjall.rs
··· 1 - use crate::db_types::{db_complete, DbBytes, DbStaticStr, StaticStr}; 1 + use crate::db_types::{db_complete, DbBytes, DbStaticStr, EncodingResult, StaticStr}; 2 2 use crate::error::StorageError; 3 3 use crate::storage::{StorageResult, StorageWhatever, StoreBackground, StoreReader, StoreWriter}; 4 4 use crate::store_types::{ ··· 9 9 NewRollupCursorKey, NewRollupCursorValue, NsidRecordFeedKey, NsidRecordFeedVal, 10 10 RecordLocationKey, RecordLocationMeta, RecordLocationVal, RecordRawValue, SketchSecretKey, 11 11 SketchSecretPrefix, TakeoffKey, TakeoffValue, TrimCollectionCursorKey, WeekTruncatedCursor, 12 - WeeklyDidsKey, WeeklyRecordsKey, WeeklyRollupKey, WithCollection, 12 + WeeklyDidsKey, WeeklyRecordsKey, WeeklyRollupKey, WithCollection, WithRank, 13 13 }; 14 14 use crate::{ 15 15 CommitAction, ConsumerInfo, Did, EventBatch, Nsid, NsidCount, OrderCollectionsBy, UFOsRecord, ··· 346 346 Ok((nsid, get_counts)) 347 347 }))) 348 348 } 349 + type GetRollupKey = Arc<dyn Fn(&Nsid) -> EncodingResult<Vec<u8>>>; 350 + fn get_lookup_iter<T: WithCollection + WithRank + DbBytes + 'static>( 351 + snapshot: lsm_tree::Snapshot, 352 + start: Bound<Vec<u8>>, 353 + end: Bound<Vec<u8>>, 354 + get_rollup_key: GetRollupKey, 355 + ) -> StorageResult<NsidCounter> { 356 + Ok(Box::new(snapshot.range((start, end)).rev().map( 357 + move |kv| { 358 + let (k_bytes, _) = kv?; 359 + let key = db_complete::<T>(&k_bytes)?; 360 + let nsid = key.collection().clone(); 361 + let get_counts: GetCounts = Box::new({ 362 + let nsid = nsid.clone(); 363 + let snapshot = snapshot.clone(); 364 + let get_rollup_key = get_rollup_key.clone(); 365 + move || { 366 + let db_count_bytes = snapshot.get(get_rollup_key(&nsid)?)?.expect( 367 + "integrity: all-time rank rollup must have corresponding all-time count rollup", 368 + ); 369 + Ok(db_complete::<CountsValue>(&db_count_bytes)?) 370 + } 371 + }); 372 + Ok((nsid, get_counts)) 373 + }, 374 + ))) 375 + } 349 376 350 377 impl FjallReader { 351 378 fn get_storage_stats(&self) -> StorageResult<serde_json::Value> { ··· 406 433 Ok(cursor) 407 434 } 408 435 409 - fn get_collections( 436 + fn get_lexi_collections( 410 437 &self, 438 + snapshot: Snapshot, 411 439 limit: usize, 412 - order: OrderCollectionsBy, 413 - since: Option<HourTruncatedCursor>, 414 - until: Option<HourTruncatedCursor>, 440 + cursor: Option<Vec<u8>>, 441 + buckets: Vec<CursorBucket>, 415 442 ) -> StorageResult<(Vec<NsidCount>, Option<Vec<u8>>)> { 416 - let snapshot = self.rollups.snapshot(); 417 - 418 - let buckets = if let (None, None) = (since, until) { 419 - vec![CursorBucket::AllTime] 420 - } else { 421 - let mut lower = self.get_earliest_hour(Some(&snapshot))?; 422 - if let Some(specified) = since { 423 - if specified > lower { 424 - lower = specified; 425 - } 426 - } 427 - let upper = until.unwrap_or_else(|| Cursor::at(SystemTime::now()).into()); 428 - CursorBucket::buckets_spanning(lower, upper) 429 - }; 430 - 443 + let cursor_nsid = cursor.as_deref().map(db_complete::<Nsid>).transpose()?; 431 444 let mut iters: Vec<Peekable<NsidCounter>> = Vec::with_capacity(buckets.len()); 432 - 433 - match order { 434 - OrderCollectionsBy::Lexi { cursor } => { 435 - let cursor_nsid = cursor.as_deref().map(db_complete::<Nsid>).transpose()?; 436 - for bucket in &buckets { 437 - let it: NsidCounter = match bucket { 438 - CursorBucket::Hour(t) => { 439 - let start = cursor_nsid 440 - .as_ref() 441 - .map(|nsid| HourlyRollupKey::after_nsid(*t, nsid)) 442 - .unwrap_or_else(|| HourlyRollupKey::start(*t))?; 443 - let end = HourlyRollupKey::end(*t)?; 444 - get_lexi_iter::<HourlyRollupKey>(&snapshot, start, end)? 445 - } 446 - CursorBucket::Week(t) => { 447 - let start = cursor_nsid 448 - .as_ref() 449 - .map(|nsid| WeeklyRollupKey::after_nsid(*t, nsid)) 450 - .unwrap_or_else(|| WeeklyRollupKey::start(*t))?; 451 - let end = WeeklyRollupKey::end(*t)?; 452 - get_lexi_iter::<WeeklyRollupKey>(&snapshot, start, end)? 453 - } 454 - CursorBucket::AllTime => { 455 - let start = cursor_nsid 456 - .as_ref() 457 - .map(AllTimeRollupKey::after_nsid) 458 - .unwrap_or_else(AllTimeRollupKey::start)?; 459 - let end = AllTimeRollupKey::end()?; 460 - get_lexi_iter::<AllTimeRollupKey>(&snapshot, start, end)? 461 - } 462 - }; 463 - iters.push(it.peekable()); 445 + for bucket in &buckets { 446 + let it: NsidCounter = match bucket { 447 + CursorBucket::Hour(t) => { 448 + let start = cursor_nsid 449 + .as_ref() 450 + .map(|nsid| HourlyRollupKey::after_nsid(*t, nsid)) 451 + .unwrap_or_else(|| HourlyRollupKey::start(*t))?; 452 + let end = HourlyRollupKey::end(*t)?; 453 + get_lexi_iter::<HourlyRollupKey>(&snapshot, start, end)? 464 454 } 465 - } 466 - OrderCollectionsBy::RecordsCreated => todo!(), 467 - OrderCollectionsBy::DidsEstimate => todo!(), 455 + CursorBucket::Week(t) => { 456 + let start = cursor_nsid 457 + .as_ref() 458 + .map(|nsid| WeeklyRollupKey::after_nsid(*t, nsid)) 459 + .unwrap_or_else(|| WeeklyRollupKey::start(*t))?; 460 + let end = WeeklyRollupKey::end(*t)?; 461 + get_lexi_iter::<WeeklyRollupKey>(&snapshot, start, end)? 462 + } 463 + CursorBucket::AllTime => { 464 + let start = cursor_nsid 465 + .as_ref() 466 + .map(AllTimeRollupKey::after_nsid) 467 + .unwrap_or_else(AllTimeRollupKey::start)?; 468 + let end = AllTimeRollupKey::end()?; 469 + get_lexi_iter::<AllTimeRollupKey>(&snapshot, start, end)? 470 + } 471 + }; 472 + iters.push(it.peekable()); 468 473 } 469 474 470 475 let mut out = Vec::new(); ··· 508 513 Ok((out, next_cursor)) 509 514 } 510 515 511 - fn get_top_collections_by_count( 516 + fn get_ordered_collections( 512 517 &self, 518 + snapshot: Snapshot, 513 519 limit: usize, 514 - since: Option<HourTruncatedCursor>, 515 - until: Option<HourTruncatedCursor>, 520 + order: OrderCollectionsBy, 521 + buckets: Vec<CursorBucket>, 516 522 ) -> StorageResult<Vec<NsidCount>> { 517 - Ok(if since.is_none() && until.is_none() { 518 - let snapshot = self.rollups.snapshot(); 519 - let mut out = Vec::with_capacity(limit); 520 - let prefix = AllTimeRecordsKey::from_prefix_to_db_bytes(&Default::default())?; 521 - for kv in snapshot.prefix(prefix).rev().take(limit) { 522 - let (key_bytes, _) = kv?; 523 - let key = db_complete::<AllTimeRecordsKey>(&key_bytes)?; 524 - let rollup_key = AllTimeRollupKey::new(key.collection()); 525 - let db_count_bytes = snapshot.get(rollup_key.to_db_bytes()?)?.expect( 526 - "integrity: all-time rank rollup must have corresponding all-time count rollup", 527 - ); 528 - let db_counts = db_complete::<CountsValue>(&db_count_bytes)?; 529 - assert_eq!(db_counts.records(), key.count()); 530 - out.push(NsidCount { 531 - nsid: key.collection().to_string(), 532 - records: db_counts.records(), 533 - dids_estimate: db_counts.dids().estimate() as u64, 534 - }); 523 + let mut iters: Vec<NsidCounter> = Vec::with_capacity(buckets.len()); 524 + 525 + for bucket in buckets { 526 + let it: NsidCounter = match (&order, bucket) { 527 + (OrderCollectionsBy::RecordsCreated, CursorBucket::Hour(t)) => { 528 + get_lookup_iter::<HourlyRecordsKey>( 529 + snapshot.clone(), 530 + HourlyRecordsKey::start(t)?, 531 + HourlyRecordsKey::end(t)?, 532 + Arc::new({ 533 + move |collection| HourlyRollupKey::new(t, collection).to_db_bytes() 534 + }), 535 + )? 536 + } 537 + (OrderCollectionsBy::DidsEstimate, CursorBucket::Hour(t)) => { 538 + get_lookup_iter::<HourlyDidsKey>( 539 + snapshot.clone(), 540 + HourlyDidsKey::start(t)?, 541 + HourlyDidsKey::end(t)?, 542 + Arc::new({ 543 + move |collection| HourlyRollupKey::new(t, collection).to_db_bytes() 544 + }), 545 + )? 546 + } 547 + (OrderCollectionsBy::RecordsCreated, CursorBucket::Week(t)) => { 548 + get_lookup_iter::<WeeklyRecordsKey>( 549 + snapshot.clone(), 550 + WeeklyRecordsKey::start(t)?, 551 + WeeklyRecordsKey::end(t)?, 552 + Arc::new({ 553 + move |collection| WeeklyRollupKey::new(t, collection).to_db_bytes() 554 + }), 555 + )? 556 + } 557 + (OrderCollectionsBy::DidsEstimate, CursorBucket::Week(t)) => { 558 + get_lookup_iter::<WeeklyDidsKey>( 559 + snapshot.clone(), 560 + WeeklyDidsKey::start(t)?, 561 + WeeklyDidsKey::end(t)?, 562 + Arc::new({ 563 + move |collection| WeeklyRollupKey::new(t, collection).to_db_bytes() 564 + }), 565 + )? 566 + } 567 + (OrderCollectionsBy::RecordsCreated, CursorBucket::AllTime) => { 568 + get_lookup_iter::<AllTimeRecordsKey>( 569 + snapshot.clone(), 570 + AllTimeRecordsKey::start()?, 571 + AllTimeRecordsKey::end()?, 572 + Arc::new(|collection| AllTimeRollupKey::new(collection).to_db_bytes()), 573 + )? 574 + } 575 + (OrderCollectionsBy::DidsEstimate, CursorBucket::AllTime) => { 576 + get_lookup_iter::<AllTimeDidsKey>( 577 + snapshot.clone(), 578 + AllTimeDidsKey::start()?, 579 + AllTimeDidsKey::end()?, 580 + Arc::new(|collection| AllTimeRollupKey::new(collection).to_db_bytes()), 581 + )? 582 + } 583 + (OrderCollectionsBy::Lexi { .. }, _) => unreachable!(), 584 + }; 585 + iters.push(it); 586 + } 587 + 588 + // overfetch by taking a bit more than the limit 589 + // merge by collection 590 + // sort by requested order, take limit, discard all remaining 591 + // 592 + // this isn't guaranteed to be correct, but it will hopefully be close most of the time: 593 + // - it's possible that some NSIDs might score low during some time-buckets, and miss being merged 594 + // - overfetching hopefully helps a bit by catching nsids near the threshold more often, but. yeah. 595 + // 596 + // this thing is heavy, there's probably a better way 597 + let mut ranked: HashMap<Nsid, CountsValue> = HashMap::with_capacity(limit * 2); 598 + for iter in iters { 599 + for pair in iter.take((limit as f64 * 1.3).ceil() as usize) { 600 + let (nsid, get_counts) = pair?; 601 + let counts = get_counts()?; 602 + ranked.entry(nsid).or_default().merge(&counts); 535 603 } 536 - out 537 - } else { 538 - todo!() 539 - }) 604 + } 605 + let mut ranked: Vec<(Nsid, CountsValue)> = ranked.into_iter().collect(); 606 + match order { 607 + OrderCollectionsBy::RecordsCreated => ranked.sort_by_key(|(_, c)| c.records()), 608 + OrderCollectionsBy::DidsEstimate => ranked.sort_by_key(|(_, c)| c.dids().estimate()), 609 + OrderCollectionsBy::Lexi { .. } => unreachable!(), 610 + } 611 + let counts = ranked 612 + .into_iter() 613 + .rev() 614 + .take(limit) 615 + .map(|(nsid, cv)| NsidCount { 616 + nsid: nsid.to_string(), 617 + records: cv.records(), 618 + dids_estimate: cv.dids().estimate() as u64, 619 + }) 620 + .collect(); 621 + Ok(counts) 540 622 } 541 623 542 - fn get_top_collections_by_dids( 624 + fn get_collections( 543 625 &self, 544 626 limit: usize, 627 + order: OrderCollectionsBy, 545 628 since: Option<HourTruncatedCursor>, 546 629 until: Option<HourTruncatedCursor>, 547 - ) -> StorageResult<Vec<NsidCount>> { 548 - Ok(if since.is_none() && until.is_none() { 549 - let snapshot = self.rollups.snapshot(); 550 - let mut out = Vec::with_capacity(limit); 551 - let prefix = AllTimeDidsKey::from_prefix_to_db_bytes(&Default::default())?; 552 - for kv in snapshot.prefix(prefix).rev().take(limit) { 553 - let (key_bytes, _) = kv?; 554 - let key = db_complete::<AllTimeDidsKey>(&key_bytes)?; 555 - let rollup_key = AllTimeRollupKey::new(key.collection()); 556 - let db_count_bytes = snapshot.get(rollup_key.to_db_bytes()?)?.expect( 557 - "integrity: all-time rank rollup must have corresponding all-time count rollup", 558 - ); 559 - let db_counts = db_complete::<CountsValue>(&db_count_bytes)?; 560 - assert_eq!(db_counts.dids().estimate() as u64, key.count()); 561 - out.push(NsidCount { 562 - nsid: key.collection().to_string(), 563 - records: db_counts.records(), 564 - dids_estimate: db_counts.dids().estimate() as u64, 565 - }); 566 - } 567 - out 630 + ) -> StorageResult<(Vec<NsidCount>, Option<Vec<u8>>)> { 631 + let snapshot = self.rollups.snapshot(); 632 + let buckets = if let (None, None) = (since, until) { 633 + vec![CursorBucket::AllTime] 568 634 } else { 569 - todo!() 570 - }) 635 + let mut lower = self.get_earliest_hour(Some(&snapshot))?; 636 + if let Some(specified) = since { 637 + if specified > lower { 638 + lower = specified; 639 + } 640 + } 641 + let upper = until.unwrap_or_else(|| Cursor::at(SystemTime::now()).into()); 642 + CursorBucket::buckets_spanning(lower, upper) 643 + }; 644 + match order { 645 + OrderCollectionsBy::Lexi { cursor } => { 646 + self.get_lexi_collections(snapshot, limit, cursor, buckets) 647 + } 648 + _ => Ok(( 649 + self.get_ordered_collections(snapshot, limit, order, buckets)?, 650 + None, 651 + )), 652 + } 571 653 } 572 654 573 655 fn get_counts_by_collection(&self, collection: &Nsid) -> StorageResult<(u64, u64)> { ··· 679 761 let s = self.clone(); 680 762 tokio::task::spawn_blocking(move || { 681 763 FjallReader::get_collections(&s, limit, order, since, until) 682 - }) 683 - .await? 684 - } 685 - async fn get_top_collections_by_count( 686 - &self, 687 - limit: usize, 688 - since: Option<HourTruncatedCursor>, 689 - until: Option<HourTruncatedCursor>, 690 - ) -> StorageResult<Vec<NsidCount>> { 691 - let s = self.clone(); 692 - tokio::task::spawn_blocking(move || { 693 - FjallReader::get_top_collections_by_count(&s, limit, since, until) 694 - }) 695 - .await? 696 - } 697 - async fn get_top_collections_by_dids( 698 - &self, 699 - limit: usize, 700 - since: Option<HourTruncatedCursor>, 701 - until: Option<HourTruncatedCursor>, 702 - ) -> StorageResult<Vec<NsidCount>> { 703 - let s = self.clone(); 704 - tokio::task::spawn_blocking(move || { 705 - FjallReader::get_top_collections_by_dids(&s, limit, since, until) 706 764 }) 707 765 .await? 708 766 }
-16
ufos/src/storage_mem.rs
··· 556 556 ) -> StorageResult<(Vec<NsidCount>, Option<Vec<u8>>)> { 557 557 todo!() 558 558 } 559 - async fn get_top_collections_by_count( 560 - &self, 561 - _: usize, 562 - _: Option<HourTruncatedCursor>, 563 - _: Option<HourTruncatedCursor>, 564 - ) -> StorageResult<Vec<NsidCount>> { 565 - todo!() 566 - } 567 - async fn get_top_collections_by_dids( 568 - &self, 569 - _: usize, 570 - _: Option<HourTruncatedCursor>, 571 - _: Option<HourTruncatedCursor>, 572 - ) -> StorageResult<Vec<NsidCount>> { 573 - todo!() 574 - } 575 559 async fn get_counts_by_collection(&self, collection: &Nsid) -> StorageResult<(u64, u64)> { 576 560 let s = self.clone(); 577 561 let collection = collection.clone();
+37
ufos/src/store_types.rs
··· 69 69 fn collection(&self) -> &Nsid; 70 70 } 71 71 72 + pub trait WithRank { 73 + fn rank(&self) -> u64; 74 + } 75 + 72 76 pub type NsidRecordFeedKey = DbConcat<Nsid, Cursor>; 73 77 impl NsidRecordFeedKey { 74 78 pub fn collection(&self) -> &Nsid { ··· 313 317 pub fn with_rank(&self, new_rank: KeyRank) -> Self { 314 318 Self::new(self.prefix.suffix.clone(), new_rank, &self.suffix.suffix) 315 319 } 320 + pub fn start(cursor: C) -> EncodingResult<Bound<Vec<u8>>> { 321 + let prefix: DbConcat<DbStaticStr<P>, C> = DbConcat::from_pair(Default::default(), cursor); 322 + Ok(Bound::Included(Self::from_prefix_to_db_bytes(&prefix)?)) 323 + } 324 + pub fn end(cursor: C) -> EncodingResult<Bound<Vec<u8>>> { 325 + let prefix: DbConcat<DbStaticStr<P>, C> = DbConcat::from_pair(Default::default(), cursor); 326 + Ok(Bound::Excluded(Self::prefix_range_end(&prefix)?)) 327 + } 328 + } 329 + impl<P: StaticStr, C: DbBytes> WithCollection for BucketedRankRecordsKey<P, C> { 330 + fn collection(&self) -> &Nsid { 331 + &self.suffix.suffix 332 + } 333 + } 334 + impl<P: StaticStr, C: DbBytes> WithRank for BucketedRankRecordsKey<P, C> { 335 + fn rank(&self) -> u64 { 336 + self.suffix.prefix.into() 337 + } 316 338 } 317 339 318 340 static_str!("hourly_counts", _HourlyRollupStaticStr); ··· 437 459 pub fn count(&self) -> u64 { 438 460 self.suffix.prefix.0 439 461 } 462 + pub fn start() -> EncodingResult<Bound<Vec<u8>>> { 463 + Ok(Bound::Included(Self::from_prefix_to_db_bytes( 464 + &Default::default(), 465 + )?)) 466 + } 467 + pub fn end() -> EncodingResult<Bound<Vec<u8>>> { 468 + Ok(Bound::Excluded( 469 + Self::prefix_range_end(&Default::default())?, 470 + )) 471 + } 440 472 } 441 473 impl<P: StaticStr> WithCollection for AllTimeRankRecordsKey<P> { 442 474 fn collection(&self) -> &Nsid { 443 475 &self.suffix.suffix 476 + } 477 + } 478 + impl<P: StaticStr> WithRank for AllTimeRankRecordsKey<P> { 479 + fn rank(&self) -> u64 { 480 + self.suffix.prefix.into() 444 481 } 445 482 } 446 483