do_memory_storage_redb/
backend_impl.rs

1use async_trait::async_trait;
2use do_memory_core::memory::attribution::{
3    RecommendationFeedback, RecommendationSession, RecommendationStats,
4};
5use do_memory_core::{Episode, Heuristic, Pattern, Result, StorageBackend, episode::PatternId};
6use uuid::Uuid;
7
8use crate::RedbStorage;
9
10#[async_trait]
11impl StorageBackend for RedbStorage {
12    async fn store_episode(&self, episode: &Episode) -> Result<()> {
13        self.store_episode(episode).await
14    }
15
16    async fn get_episode(&self, id: Uuid) -> Result<Option<Episode>> {
17        self.get_episode(id).await
18    }
19
20    async fn delete_episode(&self, id: Uuid) -> Result<()> {
21        self.delete_episode(id).await
22    }
23
24    async fn store_pattern(&self, pattern: &Pattern) -> Result<()> {
25        self.store_pattern(pattern).await
26    }
27
28    async fn get_pattern(&self, id: PatternId) -> Result<Option<Pattern>> {
29        self.get_pattern(id).await
30    }
31
32    async fn store_heuristic(&self, heuristic: &Heuristic) -> Result<()> {
33        self.store_heuristic(heuristic).await
34    }
35
36    async fn get_heuristic(&self, id: Uuid) -> Result<Option<Heuristic>> {
37        self.get_heuristic(id).await
38    }
39
40    async fn query_episodes_since(
41        &self,
42        since: chrono::DateTime<chrono::Utc>,
43        limit: Option<usize>,
44    ) -> Result<Vec<Episode>> {
45        self.query_episodes_since(since, limit).await
46    }
47
48    async fn query_episodes_by_metadata(
49        &self,
50        key: &str,
51        value: &str,
52        limit: Option<usize>,
53    ) -> Result<Vec<Episode>> {
54        self.query_episodes_by_metadata(key, value, limit).await
55    }
56
57    async fn store_embedding(&self, id: &str, embedding: Vec<f32>) -> Result<()> {
58        self.store_embedding_impl(id, embedding).await
59    }
60
61    async fn get_embedding(&self, id: &str) -> Result<Option<Vec<f32>>> {
62        self.get_embedding_impl(id).await
63    }
64
65    async fn delete_embedding(&self, id: &str) -> Result<bool> {
66        self.delete_embedding_impl(id).await
67    }
68
69    async fn store_embeddings_batch(&self, embeddings: Vec<(String, Vec<f32>)>) -> Result<()> {
70        self.store_embeddings_batch_impl(embeddings).await
71    }
72
73    async fn get_embeddings_batch(&self, ids: &[String]) -> Result<Vec<Option<Vec<f32>>>> {
74        self.get_embeddings_batch_impl(ids).await
75    }
76
77    async fn store_relationship(
78        &self,
79        relationship: &do_memory_core::episode::EpisodeRelationship,
80    ) -> Result<()> {
81        self.store_relationship(relationship).await
82    }
83
84    async fn remove_relationship(&self, relationship_id: Uuid) -> Result<()> {
85        self.remove_relationship(relationship_id).await
86    }
87
88    async fn get_relationships(
89        &self,
90        episode_id: Uuid,
91        direction: do_memory_core::episode::Direction,
92    ) -> Result<Vec<do_memory_core::episode::EpisodeRelationship>> {
93        self.get_relationships(episode_id, direction).await
94    }
95
96    async fn relationship_exists(
97        &self,
98        from_episode_id: Uuid,
99        to_episode_id: Uuid,
100        relationship_type: do_memory_core::episode::RelationshipType,
101    ) -> Result<bool> {
102        self.relationship_exists(from_episode_id, to_episode_id, relationship_type)
103            .await
104    }
105
106    async fn store_recommendation_session(&self, session: &RecommendationSession) -> Result<()> {
107        RedbStorage::store_recommendation_session(self, session).await
108    }
109
110    async fn get_recommendation_session(
111        &self,
112        session_id: Uuid,
113    ) -> Result<Option<RecommendationSession>> {
114        RedbStorage::get_recommendation_session(self, session_id).await
115    }
116
117    async fn get_recommendation_session_for_episode(
118        &self,
119        episode_id: Uuid,
120    ) -> Result<Option<RecommendationSession>> {
121        RedbStorage::get_recommendation_session_for_episode(self, episode_id).await
122    }
123
124    async fn store_recommendation_feedback(&self, feedback: &RecommendationFeedback) -> Result<()> {
125        RedbStorage::store_recommendation_feedback(self, feedback).await
126    }
127
128    async fn get_recommendation_feedback(
129        &self,
130        session_id: Uuid,
131    ) -> Result<Option<RecommendationFeedback>> {
132        RedbStorage::get_recommendation_feedback(self, session_id).await
133    }
134
135    async fn get_recommendation_stats(&self) -> Result<RecommendationStats> {
136        RedbStorage::get_recommendation_stats(self).await
137    }
138}
do_memory_storage_redb/backend_impl.rs

do_memory_storage_redb/
backend_impl.rs
