1use std::borrow::Cow;
2use std::collections::{HashMap, HashSet};
3
4use ids::{IdsFollowersRecord, IdsUnfollowedRecord};
5use itertools::Itertools as _;
6use rand::{Rng as _, RngCore as _};
7use redb::StorageError;
8use redb_bincode::{ReadableTable, Table};
9use rostra_core::event::{
10 EventContentRaw, EventExt as _, VerifiedEvent, VerifiedEventContent, content_kind,
11};
12use rostra_core::id::{RostraId, ToShort as _};
13use rostra_core::{ContentHash, ExternalEventId, ShortEventId, Timestamp};
14use tables::EventRecord;
15use tables::event::{
16 ContentStoreRecord, EventContentResult, EventContentState, EventsMissingRecord,
17};
18use tables::ids::IdsFolloweesRecord;
19use tracing::{debug, error};
20
21use super::event_order::EventOrder;
22use super::id_self::IdSelfAccountRecord;
23use super::{
24 Database, DbError, DbResult, EventsHeadsTableRecord, InsertEventOutcome, content_rc,
25 content_store, events, events_by_time, events_content_state, events_heads, events_missing,
26 events_self, get_first_in_range, get_last_in_range, ids, ids_follow_events, ids_followees,
27 ids_followers, ids_self, tables,
28};
29use crate::{
30 IdSocialProfileRecord, IdsDataUsageRecord, LOG_TARGET, Latest, LatestEventValue,
31 SocialPostRecord, WotData, events_content_missing, ids_data_usage, ids_full, social_posts,
32 social_profiles,
33};
34
35pub(crate) trait RandomTableKey: Copy + Ord {
36 fn min_key() -> Self;
37 fn random_key() -> Self;
38 fn max_key() -> Self;
39}
40
41impl RandomTableKey for ShortEventId {
42 fn min_key() -> Self {
43 Self::ZERO
44 }
45
46 fn random_key() -> Self {
47 Self::random()
48 }
49
50 fn max_key() -> Self {
51 Self::MAX
52 }
53}
54
55impl RandomTableKey for ExternalEventId {
56 fn min_key() -> Self {
57 Self::new(RostraId::ZERO, ShortEventId::ZERO)
58 }
59
60 fn random_key() -> Self {
61 let mut rng = rand::rng();
62 let mut rostra_id = [0u8; 32];
63 let mut event_id = [0u8; 16];
64 rng.fill_bytes(&mut rostra_id);
65 rng.fill_bytes(&mut event_id);
66 Self::new(
67 RostraId::from_bytes(rostra_id),
68 ShortEventId::from_bytes(event_id),
69 )
70 }
71
72 fn max_key() -> Self {
73 Self::new(RostraId::MAX, ShortEventId::MAX)
74 }
75}
76
77impl Database {
78 fn merge_deleted_by_tx(
84 current: Option<ShortEventId>,
85 candidate: Option<EventOrder>,
86 events_table: &impl events::ReadableTable,
87 ) -> DbResult<Option<ShortEventId>> {
88 let Some(candidate) = candidate else {
89 return Ok(current);
90 };
91 let Some(current_id) = current else {
92 return Ok(Some(candidate.event_id()));
93 };
94
95 let current_timestamp = events_table
96 .get(¤t_id)?
97 .map(|event| event.value().timestamp())
98 .ok_or(DbError::MissingDeletionAttribution {
99 event_id: current_id,
100 location: snafu::Location::new(file!(), line!(), column!()),
101 })?;
102
103 Ok(Some(
104 EventOrder::new(current_timestamp, current_id)
105 .max(candidate)
106 .event_id(),
107 ))
108 }
109
110 pub(crate) fn read_followees_tx(
111 id: RostraId,
112 ids_followees_table: &impl ids_followees::ReadableTable,
113 ) -> DbResult<HashMap<RostraId, IdsFolloweesRecord>> {
114 Ok(ids_followees_table
115 .range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
116 .map(|res| res.map(|(k, v)| (k.value().1, v.value())))
117 .collect::<Result<HashMap<_, _>, _>>()?)
118 }
119 pub(crate) fn read_followees_tx_iter(
120 id: RostraId,
121 ids_followees_table: &impl ids_followees::ReadableTable,
122 ) -> DbResult<impl Iterator<Item = Result<(RostraId, IdsFolloweesRecord), StorageError>>> {
123 Ok(ids_followees_table
124 .range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
125 .map_ok(|(k, v)| (k.value().1, v.value())))
126 }
127
128 pub(crate) fn read_followers_tx(
129 id: RostraId,
130 ids_followers_table: &impl ids_followers::ReadableTable,
131 ) -> DbResult<HashMap<RostraId, IdsFollowersRecord>> {
132 Ok(ids_followers_table
133 .range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
134 .map(|res| res.map(|(k, v)| (k.value().1, v.value())))
135 .collect::<Result<HashMap<_, _>, _>>()?)
136 }
137
138 pub(crate) fn compute_wot_tx(
145 self_id: RostraId,
146 direct_followees: &HashMap<RostraId, IdsFolloweesRecord>,
147 ids_followees_table: &impl ids_followees::ReadableTable,
148 ) -> DbResult<WotData> {
149 let mut extended = HashSet::new();
150
151 for followee_id in direct_followees.keys() {
152 for result in Self::read_followees_tx_iter(*followee_id, ids_followees_table)? {
154 let (ext_id, _record) = result?;
155 if ext_id != self_id && !direct_followees.contains_key(&ext_id) {
157 extended.insert(ext_id);
158 }
159 }
160 }
161
162 Ok(WotData {
163 followees: direct_followees.clone(),
164 extended,
165 })
166 }
167
168 pub(crate) fn insert_self_event_id_tx(
169 event_id: impl Into<rostra_core::ShortEventId>,
170 events_self_table: &mut events_self::Table,
171 ) -> DbResult<()> {
172 events_self_table.insert(&event_id.into(), &())?;
173 Ok(())
174 }
175
176 #[allow(clippy::too_many_arguments)]
202 pub(crate) fn insert_event_tx(
203 event: VerifiedEvent,
204 ids_full_t: &mut ids_full::Table,
205 events_table: &mut events::Table,
206 events_missing_table: &mut events_missing::Table,
207 events_heads_table: &mut events_heads::Table,
208 events_by_time_table: &mut events_by_time::Table,
209 events_content_state_table: &mut events_content_state::Table,
210 content_store_table: &mut content_store::Table,
211 content_rc_table: &mut content_rc::Table,
212 events_content_missing_table: &mut events_content_missing::Table,
213 mut ids_data_usage_table: Option<&mut ids_data_usage::Table>,
214 ) -> DbResult<InsertEventOutcome> {
215 let author = event.author();
216 let event_id = event.event_id.to_short();
217
218 ids_full_t.register(author)?;
219
220 if events_table.get(&event_id)?.is_some() {
221 return Ok(InsertEventOutcome::AlreadyPresent);
222 }
223
224 let (was_missing, is_deleted) = match events_missing_table
225 .remove(&(author, event_id))?
226 .map(|g| g.value())
227 {
228 Some(prev_missing) => {
229 (
231 true,
232 if let Some(deleted_by) = prev_missing.deleted_by {
233 events_content_state_table
234 .insert(&event_id, &EventContentState::Deleted { deleted_by })?;
235 true
236 } else {
237 false
238 },
239 )
240 }
241 _ => {
242 events_heads_table.insert(&(author, event_id), &EventsHeadsTableRecord)?;
244 (false, false)
245 }
246 };
247
248 let parent_ids = if event.parent_aux() == event.parent_prev() {
251 vec![(event.parent_aux(), true)]
252 } else {
253 vec![(event.parent_aux(), true), (event.parent_prev(), false)]
254 };
255
256 let mut deleted_parent = None;
257
258 let mut reverted_parent_content: Option<EventContentRaw> = None;
259 let mut missing_parents = vec![];
260
261 for (parent_id, parent_is_aux) in parent_ids {
262 let Some(parent_id) = parent_id else {
263 continue;
264 };
265
266 let parent_event = events_table
267 .get(&parent_id)?
268 .map(|r| r.value())
269 .filter(|parent| parent.author() == author);
270 if let Some(parent_event_record) = parent_event {
271 if event.is_delete_parent_aux_content_set() && parent_is_aux {
272 deleted_parent = Some(parent_id);
273
274 let parent_content_hash = parent_event_record.content_hash();
275 let old_state = events_content_state_table
276 .get(&parent_id)?
277 .map(|state| state.value());
278 let deleted_by = Self::merge_deleted_by_tx(
279 match old_state {
280 Some(EventContentState::Deleted { deleted_by }) => Some(deleted_by),
281 _ => None,
282 },
283 Some(EventOrder::new(event.timestamp(), event_id)),
284 events_table,
285 )?
286 .expect("a direct deletion candidate always produces attribution");
287 events_content_state_table
288 .insert(&parent_id, &EventContentState::Deleted { deleted_by })?;
289
290 if let Some(EventContentState::Missing {
291 next_fetch_attempt, ..
292 }) = old_state
293 {
294 events_content_missing_table.remove(&(next_fetch_attempt, parent_id))?;
295 }
296
297 let rc_already_decremented = matches!(
300 old_state,
301 Some(
302 EventContentState::Deleted { .. }
303 | EventContentState::Pruned
304 | EventContentState::Invalid
305 )
306 );
307
308 if old_state.is_none() {
309 if let Some(ContentStoreRecord(cow)) = content_store_table
313 .get(&parent_content_hash)?
314 .map(|g| g.value())
315 {
316 reverted_parent_content = Some(cow.into_owned());
317 }
318 }
319 if !rc_already_decremented {
320 Database::decrement_content_rc_tx(parent_content_hash, content_rc_table)?;
322 }
323
324 if !matches!(old_state, Some(EventContentState::Deleted { .. })) {
329 if let Some(ref mut usage_table) = ids_data_usage_table {
330 let parent_author = parent_event_record.author();
331 Database::track_payload_deletion_tx(
332 parent_author,
333 parent_event_record.content_len(),
334 old_state.as_ref(),
335 usage_table,
336 )?;
337 }
338 }
339 }
340 } else {
341 let old_deleted_by = events_missing_table
343 .get(&(author, parent_id))?
344 .and_then(|record| record.value().deleted_by);
345 let deleted_by = Self::merge_deleted_by_tx(
346 old_deleted_by,
347 (event.is_delete_parent_aux_content_set() && parent_is_aux)
348 .then_some(EventOrder::new(event.timestamp(), event_id)),
349 events_table,
350 )?;
351 events_missing_table
352 .insert(&(author, parent_id), &EventsMissingRecord { deleted_by })?;
353 missing_parents.push(parent_id);
354 }
355 events_heads_table.remove(&(author, parent_id))?;
357 }
358
359 events_table.insert(
360 &event_id,
361 &EventRecord {
362 signed: event.into(),
363 },
364 )?;
365 events_by_time_table.insert(&(event.timestamp(), event_id), &())?;
366
367 if let Some(ref mut usage_table) = ids_data_usage_table {
369 Database::track_new_event_tx(author, usage_table)?;
370 }
371
372 let content_hash = event.content_hash();
374 if is_deleted {
375 if let Some(ref mut usage_table) = ids_data_usage_table {
376 Database::track_new_deleted_payload_tx(author, event.content_len(), usage_table)?;
377 }
378 } else {
379 Database::increment_content_rc_tx(content_hash, content_rc_table)?;
381
382 if let Some(ref mut usage_table) = ids_data_usage_table {
384 Database::track_new_payload_tx(author, event.content_len(), usage_table)?;
385 }
386
387 if 0 < event.content_len() {
388 events_content_state_table.insert(
390 &event_id,
391 &EventContentState::Missing {
392 last_fetch_attempt: None,
393 fetch_attempt_count: 0,
394 next_fetch_attempt: Timestamp::ZERO,
395 },
396 )?;
397
398 if content_store_table.get(&content_hash)?.is_none() {
399 events_content_missing_table.insert(&(Timestamp::ZERO, event_id), &())?;
400 }
401 } else {
402 if content_store_table.get(&content_hash)?.is_none() {
404 content_store_table.insert(
405 &content_hash,
406 &ContentStoreRecord(Cow::Owned(EventContentRaw::new(vec![]))),
407 )?;
408 }
409 if let Some(ref mut usage_table) = ids_data_usage_table {
411 Database::track_payload_processed_tx(author, event.content_len(), usage_table)?;
412 }
413 }
414 }
415
416 Ok(InsertEventOutcome::Inserted {
417 was_missing,
418 is_deleted,
419 deleted_parent,
420 reverted_parent_content,
421 missing_parents,
422 }
423 .validate())
424 }
425
426 pub(crate) fn can_insert_event_content_tx(
443 VerifiedEventContent { event, .. }: &VerifiedEventContent,
444 events_content_state_table: &impl events_content_state::ReadableTable,
445 ) -> DbResult<bool> {
446 let event_id = event.event_id.to_short();
447
448 if let Some(state) = events_content_state_table
450 .get(&event_id)?
451 .map(|g| g.value())
452 {
453 match state {
454 EventContentState::Missing { .. } => {
455 return Ok(true);
457 }
458 EventContentState::Deleted { .. }
459 | EventContentState::Pruned
460 | EventContentState::Invalid => {
461 return Ok(false);
463 }
464 }
465 }
466
467 Ok(false)
470 }
471
472 pub(crate) fn prune_event_content_tx(
477 event_id: impl Into<ShortEventId>,
478 content_hash: ContentHash,
479 events_content_state_table: &mut events_content_state::Table,
480 content_rc_table: &mut content_rc::Table,
481 events_content_missing_table: &mut events_content_missing::Table,
482 data_usage_info: Option<(RostraId, u32, &mut ids_data_usage::Table)>,
483 ) -> DbResult<bool> {
484 let event_id = event_id.into();
485
486 let old_state = events_content_state_table
488 .get(&event_id)?
489 .map(|g| g.value());
490
491 match old_state {
492 Some(EventContentState::Deleted { .. }) => {
493 return Ok(false);
495 }
496 Some(EventContentState::Invalid) => {
497 return Ok(false);
499 }
500 Some(EventContentState::Pruned) => {
501 return Ok(true);
503 }
504 Some(EventContentState::Missing { .. }) | None => {
505 }
507 }
508
509 Database::decrement_content_rc_tx(content_hash, content_rc_table)?;
511
512 if let Some((author, content_len, usage_table)) = data_usage_info {
514 Database::track_payload_pruning_tx(
515 author,
516 content_len,
517 old_state.as_ref(),
518 usage_table,
519 )?;
520 }
521
522 events_content_state_table.insert(&event_id, &EventContentState::Pruned)?;
523 if let Some(EventContentState::Missing {
524 next_fetch_attempt, ..
525 }) = old_state
526 {
527 events_content_missing_table.remove(&(next_fetch_attempt, event_id))?;
528 }
529
530 Ok(true)
531 }
532
533 pub(crate) fn get_missing_events_for_id_tx(
534 author: RostraId,
535 events_missing_table: &impl events_missing::ReadableTable,
536 ) -> DbResult<Vec<ShortEventId>> {
537 Ok(events_missing_table
538 .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
539 .map(|r| r.map(|(k, _v)| k.value().1))
540 .collect::<Result<Vec<_>, _>>()?)
541 }
542
543 pub(crate) fn get_ids_with_missing_events_tx(
544 after: Option<RostraId>,
545 limit: usize,
546 events_missing_table: &impl events_missing::ReadableTable,
547 ) -> DbResult<Vec<RostraId>> {
548 if limit == 0 {
549 return Ok(Vec::new());
550 }
551 let start = after.map_or(std::ops::Bound::Unbounded, |author| {
552 std::ops::Bound::Excluded((author, ShortEventId::MAX))
553 });
554 let mut authors = Vec::with_capacity(limit);
555
556 for row in events_missing_table.range((start, std::ops::Bound::Unbounded))? {
557 let author = row?.0.value().0;
558 if authors.last() != Some(&author) {
559 authors.push(author);
560 if limit <= authors.len() {
561 break;
562 }
563 }
564 }
565
566 Ok(authors)
567 }
568
569 pub(crate) fn get_last_id_with_missing_events_tx(
570 events_missing_table: &impl events_missing::ReadableTable,
571 ) -> DbResult<Option<RostraId>> {
572 Ok(events_missing_table
573 .range((
574 std::ops::Bound::<(RostraId, ShortEventId)>::Unbounded,
575 std::ops::Bound::<(RostraId, ShortEventId)>::Unbounded,
576 ))?
577 .next_back()
578 .transpose()?
579 .map(|(key, _)| key.value().0))
580 }
581
582 pub(crate) fn get_heads_events_tx(
583 author: RostraId,
584 events_heads_table: &impl events_heads::ReadableTable,
585 ) -> DbResult<Vec<ShortEventId>> {
586 Ok(events_heads_table
587 .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
588 .map(|r| r.map(|(k, _v)| k.value().1))
589 .collect::<Result<Vec<_>, _>>()?)
590 }
591
592 pub(crate) fn get_ids_with_heads_tx(
593 after: Option<RostraId>,
594 limit: usize,
595 events_heads_table: &impl events_heads::ReadableTable,
596 ) -> DbResult<Vec<RostraId>> {
597 if limit == 0 {
598 return Ok(Vec::new());
599 }
600 let start = after.map_or(std::ops::Bound::Unbounded, |author| {
601 std::ops::Bound::Excluded((author, ShortEventId::MAX))
602 });
603 let mut authors = Vec::with_capacity(limit);
604
605 for row in events_heads_table.range((start, std::ops::Bound::Unbounded))? {
606 let author = row?.0.value().0;
607 if authors.last() != Some(&author) {
608 authors.push(author);
609 if limit <= authors.len() {
610 break;
611 }
612 }
613 }
614
615 Ok(authors)
616 }
617
618 pub(crate) fn count_missing_events_for_id_tx(
619 author: RostraId,
620 events_missing_table: &impl events_missing::ReadableTable,
621 ) -> DbResult<usize> {
622 Ok(events_missing_table
623 .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
624 .count())
625 }
626
627 pub(crate) fn count_heads_events_tx(
628 author: RostraId,
629 events_heads_table: &impl events_heads::ReadableTable,
630 ) -> DbResult<usize> {
631 Ok(events_heads_table
632 .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
633 .count())
634 }
635
636 pub(crate) fn get_event_tx(
637 event: impl Into<ShortEventId>,
638 events_table: &impl events::ReadableTable,
639 ) -> DbResult<Option<EventRecord>> {
640 Ok(events_table.get(&event.into())?.map(|r| r.value()))
641 }
642
643 pub(crate) fn get_social_post_tx(
644 event: impl Into<ShortEventId>,
645 social_posts_table: &impl social_posts::ReadableTable,
646 ) -> DbResult<Option<SocialPostRecord>> {
647 Ok(social_posts_table.get(&event.into())?.map(|r| r.value()))
648 }
649 pub(crate) fn has_event_tx(
650 event: impl Into<ShortEventId>,
651 events_table: &impl events::ReadableTable,
652 ) -> DbResult<bool> {
653 Ok(events_table.get(&event.into())?.is_some())
654 }
655
656 pub(crate) fn get_event_content_state_tx(
661 event: impl Into<ShortEventId>,
662 events_content_state_table: &impl events_content_state::ReadableTable,
663 ) -> DbResult<Option<EventContentState>> {
664 Ok(events_content_state_table
665 .get(&event.into())?
666 .map(|r| r.value()))
667 }
668
669 pub(crate) fn get_event_content_full_tx(
680 event_id: impl Into<ShortEventId>,
681 content_hash: ContentHash,
682 events_content_state_table: &impl events_content_state::ReadableTable,
683 content_store_table: &impl content_store::ReadableTable,
684 ) -> DbResult<Option<EventContentResult>> {
685 let event_id = event_id.into();
686
687 if let Some(state) = events_content_state_table
690 .get(&event_id)?
691 .map(|r| r.value())
692 {
693 match state {
694 EventContentState::Missing { .. } => {
695 }
698 EventContentState::Deleted { deleted_by } => {
699 return Ok(Some(EventContentResult::Deleted { deleted_by }));
700 }
701 EventContentState::Pruned => {
702 return Ok(Some(EventContentResult::Pruned));
703 }
704 EventContentState::Invalid => {
705 return Ok(Some(EventContentResult::Invalid));
706 }
707 }
708 }
709
710 Ok(Some(
712 match content_store_table.get(&content_hash)?.map(|r| r.value()) {
713 Some(ContentStoreRecord(content)) => {
714 EventContentResult::Present(content.into_owned())
715 }
716 None => EventContentResult::Missing,
717 },
718 ))
719 }
720
721 pub(crate) fn has_event_content_tx(
727 event_id: impl Into<ShortEventId>,
728 content_hash: ContentHash,
729 events_content_state_table: &impl events_content_state::ReadableTable,
730 content_store_table: &impl content_store::ReadableTable,
731 ) -> DbResult<bool> {
732 let event_id = event_id.into();
733
734 if events_content_state_table.get(&event_id)?.is_some() {
736 return Ok(false);
737 }
738
739 Ok(content_store_table.get(&content_hash)?.is_some())
741 }
742
743 #[cfg(test)]
755 pub(crate) fn is_content_available_for_event_tx(
756 event_id: impl Into<ShortEventId>,
757 content_hash: ContentHash,
758 events_content_state_table: &impl events_content_state::ReadableTable,
759 content_store_table: &impl content_store::ReadableTable,
760 ) -> DbResult<bool> {
761 let event_id = event_id.into();
762
763 if let Some(state) = events_content_state_table
765 .get(&event_id)?
766 .map(|g| g.value())
767 {
768 match state {
769 EventContentState::Missing { .. } => {}
772 EventContentState::Deleted { .. }
774 | EventContentState::Pruned
775 | EventContentState::Invalid => {
776 return Ok(false);
777 }
778 }
779 }
780
781 Ok(content_store_table.get(&content_hash)?.is_some())
783 }
784
785 pub(crate) fn insert_follow_tx(
786 author: RostraId,
787 event_order: EventOrder,
788 content: content_kind::Follow,
789 followees_table: &mut Table<(RostraId, RostraId), IdsFolloweesRecord>,
790 followers_table: &mut Table<(RostraId, RostraId), IdsFollowersRecord>,
791 follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
792 unfollowed_table: &mut Table<(RostraId, RostraId), IdsUnfollowedRecord>,
793 ) -> DbResult<bool> {
794 let followee = content.followee;
795 let db_key = (author, followee);
796 let epoch_boundary = unfollowed_table
797 .get(&db_key)?
798 .map(|record| record.value())
799 .map(|record| EventOrder::new(record.ts, record.event_id));
800 if epoch_boundary.is_some_and(|boundary| event_order <= boundary) {
801 return Ok(false);
802 }
803 follow_events_table.insert(
804 &(
805 author,
806 followee,
807 event_order.timestamp(),
808 event_order.event_id(),
809 ),
810 &(),
811 )?;
812
813 let existing = followees_table.get(&db_key)?.map(|v| v.value());
814 if let Some(ref followees) = existing {
815 if event_order <= EventOrder::new(followees.latest_ts, followees.latest_event_id) {
816 let first_ts = Self::first_follow_ts_after_tx(
817 author,
818 followee,
819 epoch_boundary,
820 follow_events_table,
821 )?
822 .unwrap_or(followees.latest_ts);
823 if first_ts == followees.first_ts {
824 return Ok(false);
825 }
826 followees_table.insert(&db_key, &followees.clone().with_first_ts(first_ts))?;
827 return Ok(true);
828 }
829 }
830
831 let timestamp = event_order.timestamp();
832 let first_ts =
833 Self::first_follow_ts_after_tx(author, followee, epoch_boundary, follow_events_table)?
834 .unwrap_or(timestamp);
835
836 let tags_selector = content.persona_tags_selector.clone();
837 let selector = content.selector();
838 followees_table.insert(
839 &db_key,
840 &IdsFolloweesRecord::new(
841 timestamp,
842 event_order.event_id(),
843 first_ts,
844 selector,
845 tags_selector,
846 ),
847 )?;
848 followers_table.insert(&(followee, author), &IdsFollowersRecord {})?;
849
850 debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Follow update");
851
852 Ok(true)
853 }
854
855 #[allow(deprecated)]
856 pub(crate) fn insert_unfollow_tx(
857 author: RostraId,
858 event_order: EventOrder,
859 followee: RostraId,
860 followees_table: &mut Table<(RostraId, RostraId), IdsFolloweesRecord>,
861 followers_table: &mut Table<(RostraId, RostraId), IdsFollowersRecord>,
862 follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
863 unfollowed_table: &mut Table<(RostraId, RostraId), IdsUnfollowedRecord>,
864 ) -> DbResult<bool> {
865 let db_key = (author, followee);
866 if let Some(unfollowed) = unfollowed_table.get(&db_key)?.map(|v| v.value()) {
867 if event_order <= EventOrder::new(unfollowed.ts, unfollowed.event_id) {
868 return Ok(false);
869 }
870 }
871
872 unfollowed_table.insert(
873 &db_key,
874 &IdsUnfollowedRecord {
875 ts: event_order.timestamp(),
876 event_id: event_order.event_id(),
877 },
878 )?;
879 Self::prune_follow_events_through_tx(author, followee, event_order, follow_events_table)?;
880
881 let existing = followees_table.get(&db_key)?.map(|v| v.value());
882 if let Some(followees) = existing {
883 if event_order < EventOrder::new(followees.latest_ts, followees.latest_event_id) {
884 let first_ts = Self::first_follow_ts_after_tx(
885 author,
886 followee,
887 Some(event_order),
888 follow_events_table,
889 )?
890 .unwrap_or(followees.latest_ts);
891 followees_table.insert(&db_key, &followees.with_first_ts(first_ts))?;
892 debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Follow epoch boundary update");
893 return Ok(true);
894 }
895 }
896
897 followees_table.remove(&db_key)?;
898 followers_table.remove(&(followee, author))?;
899 debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Unfollow update");
900
901 Ok(true)
902 }
903
904 fn first_follow_ts_after_tx(
906 author: RostraId,
907 followee: RostraId,
908 boundary: Option<EventOrder>,
909 follow_events_table: &impl ids_follow_events::ReadableTable,
910 ) -> DbResult<Option<Timestamp>> {
911 let lower = boundary
912 .map(|order| (author, followee, order.timestamp(), order.event_id()))
913 .unwrap_or((author, followee, Timestamp::ZERO, ShortEventId::ZERO));
914 let upper = (author, followee, Timestamp::MAX, ShortEventId::MAX);
915
916 for entry in follow_events_table.range(lower..=upper)? {
917 let (key, _) = entry?;
918 let (_, _, timestamp, event_id) = key.value();
919 let order = EventOrder::new(timestamp, event_id);
920 if boundary.is_none_or(|boundary| boundary < order) {
921 return Ok(Some(timestamp));
922 }
923 }
924 Ok(None)
925 }
926
927 fn prune_follow_events_through_tx(
929 author: RostraId,
930 followee: RostraId,
931 boundary: EventOrder,
932 follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
933 ) -> DbResult<()> {
934 const BATCH_SIZE: usize = 256;
935 let range = (author, followee, Timestamp::ZERO, ShortEventId::ZERO)
936 ..=(author, followee, boundary.timestamp(), boundary.event_id());
937 loop {
938 let keys = follow_events_table
942 .range(range.clone())?
943 .take(BATCH_SIZE)
944 .map(|entry| entry.map(|(key, _)| key.value()))
945 .collect::<Result<Vec<_>, _>>()?;
946 let len = keys.len();
947 for key in keys {
948 follow_events_table.remove(&key)?;
949 }
950 if len < BATCH_SIZE {
951 break;
952 }
953 }
954 Ok(())
955 }
956
957 pub(crate) fn insert_latest_value_tx<K, V>(
958 timestamp: Timestamp,
959 key: &K,
960 value: V,
961 table: &mut redb_bincode::Table<'_, K, Latest<V>>,
962 ) -> DbResult<bool>
963 where
964 K: bincode::Encode + bincode::Decode<()>,
965 V: bincode::Encode + bincode::Decode<()>,
966 V: LatestEventValue,
967 {
968 let event_order = EventOrder::new(timestamp, value.event_id());
969 if let Some(existing_value) = table.get(key)?.map(|v| v.value()) {
970 if event_order <= EventOrder::new(existing_value.ts, existing_value.inner.event_id()) {
971 return Ok(false);
972 }
973 }
974
975 table.insert(
976 key,
977 &Latest {
978 ts: timestamp,
979 inner: value,
980 },
981 )?;
982
983 Ok(true)
984 }
985
986 pub(crate) fn read_self_id_tx(
987 id_self_table: &impl ids_self::ReadableTable,
988 ) -> Result<Option<IdSelfAccountRecord>, DbError> {
989 Ok(id_self_table.get(&())?.map(|v| v.value()))
990 }
991
992 pub(crate) fn write_self_id_tx(
993 self_id: RostraId,
994 id_self_table: &mut Table<(), IdSelfAccountRecord>,
995 ) -> DbResult<IdSelfAccountRecord> {
996 let id_self_record = IdSelfAccountRecord {
997 rostra_id: self_id,
998 iroh_secret: rand::rng().random(),
999 };
1000 let _ = id_self_table.insert(&(), &id_self_record)?;
1001 Ok(id_self_record)
1002 }
1003
1004 pub(crate) fn read_head_tx(
1005 self_id: RostraId,
1006 events_heads_table: &impl ReadableTable<(RostraId, ShortEventId), EventsHeadsTableRecord>,
1007 ) -> DbResult<Option<ShortEventId>> {
1008 Ok(events_heads_table
1009 .range((self_id, ShortEventId::ZERO)..=(self_id, ShortEventId::MAX))?
1010 .next()
1011 .transpose()?
1012 .map(|(k, _)| k.value().1))
1013 }
1014
1015 pub(crate) fn get_heads_tx(
1016 self_id: RostraId,
1017 events_heads_table: &impl events_heads::ReadableTable,
1018 ) -> DbResult<HashSet<ShortEventId>> {
1019 Ok(events_heads_table
1020 .range((self_id, ShortEventId::ZERO)..=(self_id, ShortEventId::MAX))?
1021 .map(|r| r.map(|(k, _)| k.value().1))
1022 .collect::<Result<HashSet<_>, _>>()?)
1023 }
1024
1025 pub(crate) fn get_social_profile_tx(
1026 id: RostraId,
1027 table: &impl social_profiles::ReadableTable,
1028 ) -> DbResult<Option<IdSocialProfileRecord>> {
1029 Ok(table.get(&id)?.map(|v| v.value().inner))
1030 }
1031
1032 pub(crate) fn get_random_table_key<K, V>(
1033 table: &impl ReadableTable<K, V>,
1034 ) -> Result<Option<K>, DbError>
1035 where
1036 K: RandomTableKey + bincode::Decode<()> + bincode::Encode,
1037 V: bincode::Decode<()> + bincode::Encode,
1038 {
1039 let pivot = K::random_key();
1040
1041 let before_pivot = K::min_key()..pivot;
1042 let after_pivot = pivot..=K::max_key();
1043
1044 if rand::rng().random() {
1045 if let Some(key) = get_first_in_range(table, after_pivot)? {
1046 return Ok(Some(key));
1047 }
1048 return get_last_in_range(table, before_pivot);
1049 }
1050
1051 if let Some(key) = get_last_in_range(table, before_pivot)? {
1052 return Ok(Some(key));
1053 }
1054 get_first_in_range(table, after_pivot)
1055 }
1056
1057 pub(crate) fn get_random_self_event(
1058 events_self_table: &impl ReadableTable<ShortEventId, ()>,
1059 ) -> Result<Option<ShortEventId>, DbError> {
1060 Self::get_random_table_key(events_self_table)
1061 }
1062
1063 pub(crate) fn read_iroh_secret_tx(
1064 ids_self_t: &impl ids_self::ReadableTable,
1065 ) -> DbResult<iroh::SecretKey> {
1066 let self_id = Self::read_self_id_tx(ids_self_t)?
1067 .expect("Must have iroh secret generated after opening");
1068 Ok(iroh::SecretKey::from_bytes(&self_id.iroh_secret))
1069 }
1070
1071 pub(crate) fn increment_content_rc_tx(
1075 content_hash: ContentHash,
1076 content_rc_table: &mut content_rc::Table,
1077 ) -> DbResult<u64> {
1078 let current_count = content_rc_table
1079 .get(&content_hash)?
1080 .map(|g| g.value())
1081 .unwrap_or(0); let new_count = current_count + 1;
1084 content_rc_table.insert(&content_hash, &new_count)?;
1085 Ok(new_count)
1086 }
1087
1088 pub(crate) fn decrement_content_rc_tx(
1094 content_hash: ContentHash,
1095 content_rc_table: &mut content_rc::Table,
1096 ) -> DbResult<u64> {
1097 let current_count = match content_rc_table.get(&content_hash)?.map(|g| g.value()) {
1098 Some(count) => count,
1099 None => {
1100 debug_assert!(
1103 false,
1104 "Decrementing RC for content with no RC entry: {content_hash}"
1105 );
1106 error!(
1107 target: LOG_TARGET,
1108 %content_hash,
1109 "Decrementing RC for content with no RC entry - possible bug"
1110 );
1111 1
1113 }
1114 };
1115
1116 if current_count <= 1 {
1117 content_rc_table.remove(&content_hash)?;
1120 Ok(0)
1121 } else {
1122 let new_count = current_count
1123 .checked_sub(1)
1124 .expect("Reference count should never underflow");
1125 content_rc_table.insert(&content_hash, &new_count)?;
1126 Ok(new_count)
1127 }
1128 }
1129
1130 #[cfg(test)]
1132 pub(crate) fn get_content_rc_tx(
1133 content_hash: ContentHash,
1134 content_rc_table: &impl content_rc::ReadableTable,
1135 ) -> DbResult<u64> {
1136 Ok(content_rc_table
1137 .get(&content_hash)?
1138 .map(|g| g.value())
1139 .unwrap_or(0)) }
1141
1142 pub const EVENT_METADATA_SIZE: u64 = 192;
1149
1150 fn get_usage_mut(
1151 author: RostraId,
1152 ids_data_usage_table: &mut ids_data_usage::Table,
1153 ) -> DbResult<IdsDataUsageRecord> {
1154 Ok(ids_data_usage_table
1155 .get(&author)?
1156 .map(|g| g.value())
1157 .unwrap_or_default())
1158 }
1159
1160 pub(crate) fn track_new_event_tx(
1164 author: RostraId,
1165 ids_data_usage_table: &mut ids_data_usage::Table,
1166 ) -> DbResult<()> {
1167 let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1168
1169 usage.current_metadata_size += Self::EVENT_METADATA_SIZE;
1170 usage.total_metadata_size += Self::EVENT_METADATA_SIZE;
1171 usage.current_metadata_num += 1;
1172 usage.total_metadata_num += 1;
1173
1174 ids_data_usage_table.insert(&author, &usage)?;
1175 Ok(())
1176 }
1177
1178 pub(crate) fn track_new_payload_tx(
1184 author: RostraId,
1185 content_len: u32,
1186 ids_data_usage_table: &mut ids_data_usage::Table,
1187 ) -> DbResult<()> {
1188 let len = u64::from(content_len);
1189 let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1190
1191 usage.total_content_size += len;
1192 usage.total_payload_num += 1;
1193 usage.missing_payload_size += len;
1194 usage.missing_payload_num += 1;
1195
1196 ids_data_usage_table.insert(&author, &usage)?;
1197 Ok(())
1198 }
1199
1200 pub(crate) fn track_new_deleted_payload_tx(
1205 author: RostraId,
1206 content_len: u32,
1207 ids_data_usage_table: &mut ids_data_usage::Table,
1208 ) -> DbResult<()> {
1209 let len = u64::from(content_len);
1210 let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1211
1212 usage.total_content_size += len;
1213 usage.total_payload_num += 1;
1214 usage.deleted_payload_size += len;
1215 usage.deleted_payload_num += 1;
1216
1217 ids_data_usage_table.insert(&author, &usage)?;
1218 Ok(())
1219 }
1220
1221 pub(crate) fn track_payload_processed_tx(
1226 author: RostraId,
1227 content_len: u32,
1228 ids_data_usage_table: &mut ids_data_usage::Table,
1229 ) -> DbResult<()> {
1230 let len = u64::from(content_len);
1231 let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1232
1233 usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1234 usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1235 usage.current_content_size += len;
1236 usage.current_payload_num += 1;
1237
1238 ids_data_usage_table.insert(&author, &usage)?;
1239 Ok(())
1240 }
1241
1242 pub(crate) fn track_payload_invalid_tx(
1246 author: RostraId,
1247 content_len: u32,
1248 ids_data_usage_table: &mut ids_data_usage::Table,
1249 ) -> DbResult<()> {
1250 let len = u64::from(content_len);
1251 let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1252
1253 usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1254 usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1255 usage.invalid_payload_size += len;
1256 usage.invalid_payload_num += 1;
1257
1258 ids_data_usage_table.insert(&author, &usage)?;
1259 Ok(())
1260 }
1261
1262 pub(crate) fn track_payload_deletion_tx(
1270 author: RostraId,
1271 content_len: u32,
1272 old_state: Option<&EventContentState>,
1273 ids_data_usage_table: &mut ids_data_usage::Table,
1274 ) -> DbResult<()> {
1275 let len = u64::from(content_len);
1276 let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1277
1278 match old_state {
1279 Some(EventContentState::Missing { .. }) => {
1280 usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1281 usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1282 }
1283 Some(EventContentState::Invalid) => {
1284 usage.invalid_payload_size = usage.invalid_payload_size.saturating_sub(len);
1285 usage.invalid_payload_num = usage.invalid_payload_num.saturating_sub(1);
1286 }
1287 Some(EventContentState::Pruned) => {
1288 usage.pruned_payload_size = usage.pruned_payload_size.saturating_sub(len);
1289 usage.pruned_payload_num = usage.pruned_payload_num.saturating_sub(1);
1290 }
1291 None => {
1292 usage.current_content_size = usage.current_content_size.saturating_sub(len);
1293 usage.current_payload_num = usage.current_payload_num.saturating_sub(1);
1294 }
1295 Some(EventContentState::Deleted { .. }) => {}
1297 }
1298
1299 usage.deleted_payload_size += len;
1300 usage.deleted_payload_num += 1;
1301
1302 ids_data_usage_table.insert(&author, &usage)?;
1303 Ok(())
1304 }
1305
1306 pub(crate) fn track_payload_pruning_tx(
1312 author: RostraId,
1313 content_len: u32,
1314 old_state: Option<&EventContentState>,
1315 ids_data_usage_table: &mut ids_data_usage::Table,
1316 ) -> DbResult<()> {
1317 let len = u64::from(content_len);
1318 let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1319
1320 match old_state {
1321 Some(EventContentState::Missing { .. }) => {
1322 usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1323 usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1324 }
1325 None => {
1326 usage.current_content_size = usage.current_content_size.saturating_sub(len);
1327 usage.current_payload_num = usage.current_payload_num.saturating_sub(1);
1328 }
1329 _ => {}
1330 }
1331
1332 usage.pruned_payload_size += len;
1333 usage.pruned_payload_num += 1;
1334
1335 ids_data_usage_table.insert(&author, &usage)?;
1336 Ok(())
1337 }
1338
1339 pub(crate) fn get_data_usage_tx(
1341 author: RostraId,
1342 ids_data_usage_table: &impl ids_data_usage::ReadableTable,
1343 ) -> DbResult<IdsDataUsageRecord> {
1344 Ok(ids_data_usage_table
1345 .get(&author)?
1346 .map(|g| g.value())
1347 .unwrap_or_default())
1348 }
1349}