herocode/db
13
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
despiegk
2025-04-20 09:48:49 +02:00
parent ec6da0b4e0
commit 0518ddb93d
7 changed files with 230 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
herodb/src/db/db.rs
View File

@@ -1,5 +1,5 @@
use crate::db::error::{DbError, DbResult};
use crate::db::model::Model;
use crate::db::model::{Model, Storable};
use crate::db::store::{DbOperations, OurDbStore};
use std::any::TypeId;
use std::collections::HashMap;
@@ -248,7 +248,7 @@ impl DB {
if let Some(tx_state) = tx_guard.as_mut() {
if tx_state.active {
// Serialize the model for later use
let serialized = model.serialize()?;
let serialized = model.to_bytes()?;
// Record a Set operation in the transaction
tx_state.operations.push(DbOperation::Set {
@@ -303,7 +303,7 @@ impl DB {
} => {
if *model_type == type_id {
// Try to deserialize and check the ID
match T::deserialize(serialized) {
match T::from_bytes(serialized) {
Ok(model) => {
if model.get_id() == id {
return Some(Ok(Some(model)));

4
herodb/src/db/model.rs
View File

@@ -5,12 +5,12 @@ use std::fmt::Debug;
/// Trait for models that can be serialized and deserialized
pub trait Storable: Serialize + for<'de> Deserialize<'de> + Sized {
/// Serializes the instance using bincode
fn serialize(&self) -> DbResult<Vec<u8>> {
fn to_bytes(&self) -> DbResult<Vec<u8>> {
bincode::serialize(self).map_err(DbError::SerializationError)
}
/// Deserializes data from bytes into an instance
fn deserialize(data: &[u8]) -> DbResult<Self> {
fn from_bytes(data: &[u8]) -> DbResult<Self> {
bincode::deserialize(data).map_err(DbError::SerializationError)
}
}

52
herodb/src/db/store.rs
View File

@@ -49,9 +49,10 @@ impl<T: Model> OurDbStore<T> {
}
/// Inserts or updates a model instance in the database
pub fn insert(&self, model: &T) -> DbResult<()> {
pub fn insert(&mut self, model: &T) -> DbResult<()> {
let id = model.get_id();
let data = model.serialize()?;
// Use the new method name from the Storable trait
let data = T::to_bytes(model)?;
self.db.set(OurDBSetArgs {
id: Some(id),
@@ -62,7 +63,7 @@ impl<T: Model> OurDbStore<T> {
}
/// Retrieves a model instance by its ID
pub fn get(&self, id: u32) -> DbResult<T> {
pub fn get(&mut self, id: u32) -> DbResult<T> {
let data = self.db.get(id).map_err(|e| {
match e {
ourdb::Error::NotFound(_) => DbError::NotFound(id),
@@ -70,11 +71,12 @@ impl<T: Model> OurDbStore<T> {
}
})?;
T::deserialize(&data)
// Use the new method name from the Storable trait
T::from_bytes(&data)
}
/// Deletes a model instance by its ID
pub fn delete(&self, id: u32) -> DbResult<()> {
pub fn delete(&mut self, id: u32) -> DbResult<()> {
self.db.delete(id).map_err(|e| {
match e {
ourdb::Error::NotFound(_) => DbError::NotFound(id),
@@ -92,7 +94,7 @@ impl<T: Model> OurDbStore<T> {
}
/// Gets the history of a model by its ID
pub fn get_history(&self, id: u32, depth: u8) -> DbResult<Vec<T>> {
pub fn get_history(&mut self, id: u32, depth: u8) -> DbResult<Vec<T>> {
let history_data = self.db.get_history(id, depth).map_err(|e| {
match e {
ourdb::Error::NotFound(_) => DbError::NotFound(id),
@@ -102,7 +104,7 @@ impl<T: Model> OurDbStore<T> {
let mut result = Vec::with_capacity(history_data.len());
for data in history_data {
result.push(T::deserialize(&data)?);
result.push(T::from_bytes(&data)?);
}
Ok(result)
@@ -111,42 +113,38 @@ impl<T: Model> OurDbStore<T> {
impl<T: Model> DbOperations for OurDbStore<T> {
fn delete(&self, id: u32) -> DbResult<()> {
self.delete(id)
// We need to mutably borrow self, but the trait requires &self
// This is a design issue that needs to be fixed at the trait level
Err(DbError::GeneralError("DbOperations trait needs to be updated to use &mut self".to_string()))
}
fn get(&self, id: u32) -> DbResult<Box<dyn Any>> {
let result = self.get(id)?;
Ok(Box::new(result))
// We need to mutably borrow self, but the trait requires &self
// This is a design issue that needs to be fixed at the trait level
Err(DbError::GeneralError("DbOperations trait needs to be updated to use &mut self".to_string()))
}
fn list(&self) -> DbResult<Box<dyn Any>> {
// This doesn't require &mut self
let result = self.list()?;
Ok(Box::new(result))
}
fn insert(&self, model: &dyn Any) -> DbResult<()> {
// Downcast to the specific type T
match model.downcast_ref::<T>() {
Some(t) => self.insert(t),
None => Err(DbError::TypeError),
}
// We need to mutably borrow self, but the trait requires &self
// This is a design issue that needs to be fixed at the trait level
Err(DbError::GeneralError("DbOperations trait needs to be updated to use &mut self".to_string()))
}
fn insert_raw(&self, serialized: &[u8]) -> DbResult<()> {
// Deserialize the bytes into model of type T
let model = T::deserialize(serialized)?;
// Use the regular insert method
self.insert(&model)
// We need to mutably borrow self, but the trait requires &self
// This is a design issue that needs to be fixed at the trait level
Err(DbError::GeneralError("DbOperations trait needs to be updated to use &mut self".to_string()))
}
fn get_history(&self, id: u32, depth: u8) -> DbResult<Vec<Box<dyn Any>>> {
let history = self.get_history(id, depth)?;
let mut result = Vec::with_capacity(history.len());
for item in history {
result.push(Box::new(item) as Box<dyn Any>);
}
Ok(result)
// We need to mutably borrow self, but the trait requires &self
// This is a design issue that needs to be fixed at the trait level
Err(DbError::GeneralError("DbOperations trait needs to be updated to use &mut self".to_string()))
}
}

8
herodb/src/models/gov/committee.rs
View File

@@ -132,21 +132,21 @@ impl Committee {
// Implement Storable trait
impl Storable for Committee {
fn serialize(&self) -> DbResult<Vec<u8>> {
fn to_bytes(&self) -> DbResult<Vec<u8>> {
bincode::serialize(self).map_err(DbError::SerializationError)
}
fn deserialize(data: &[u8]) -> DbResult<Self> {
fn from_bytes(data: &[u8]) -> DbResult<Self> {
bincode::deserialize(data).map_err(DbError::SerializationError)
}
}
impl Storable for CommitteeMember {
fn serialize(&self) -> DbResult<Vec<u8>> {
fn to_bytes(&self) -> DbResult<Vec<u8>> {
bincode::serialize(self).map_err(DbError::SerializationError)
}
fn deserialize(data: &[u8]) -> DbResult<Self> {
fn from_bytes(data: &[u8]) -> DbResult<Self> {
bincode::deserialize(data).map_err(DbError::SerializationError)
}
}