refactor error

Author: xx01cyx

optd-cost-model/src/lib.rs

@@ -2,7 +2,10 @@ use common::{
     nodes::{ArcPredicateNode, PhysicalNodeType},
     types::{AttrId, EpochId, ExprId, GroupId, TableId},
 };
-use optd_persistent::cost_model::interface::{Stat, StatType};
+use optd_persistent::{
+    cost_model::interface::{Stat, StatType},
+    BackendError,
+};
 
 pub mod common;
 pub mod cost;
@@ -32,10 +35,19 @@ pub struct EstimatedStatistic(pub u64);
 
 pub type CostModelResult<T> = Result<T, CostModelError>;
 
+#[derive(Debug)]
+pub enum SemanticError {
+    // TODO: Add more error types
+    UnknownStatisticType,
+    VersionedStatisticNotFound,
+    AttributeNotFound,
+}
+
 #[derive(Debug)]
 pub enum CostModelError {
     // TODO: Add more error types
-    ORMError,
+    ORMError(BackendError),
+    SemanticError(SemanticError),
 }
 
 pub trait CostModel: 'static + Send + Sync {

optd-persistent/src/cost_model/interface.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code, unused_imports)]
 
+use crate::entities::attribute::Model as AttributeEntity;
 use crate::entities::cascades_group;
-use crate::entities::event::Model as event_model;
 use crate::entities::logical_expression;
 use crate::entities::physical_expression;
 use crate::StorageResult;
@@ -58,7 +58,7 @@ pub enum EpochOption {
 }
 
 /// TODO: documentation
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Stat {
     pub stat_type: i32,
     pub stat_value: Json,

optd-persistent/src/cost_model/orm.rs

@@ -1,10 +1,8 @@
 #![allow(dead_code, unused_imports, unused_variables)]
 
-use std::ptr::null;
-
 use crate::cost_model::interface::Cost;
 use crate::entities::{prelude::*, *};
-use crate::{BackendError, BackendManager, CostModelError, CostModelStorageLayer, StorageResult};
+use crate::{BackendError, BackendManager, CostModelStorageLayer, StorageResult};
 use sea_orm::prelude::{Expr, Json};
 use sea_orm::sea_query::Query;
 use sea_orm::{sqlx::types::chrono::Utc, EntityTrait};
@@ -246,10 +244,9 @@ impl CostModelStorageLayer for BackendManager {
                         match res {
                             Ok(insert_res) => insert_res.last_insert_id,
                             Err(_) => {
-                                return Err(BackendError::Database(DbErr::Exec(
-                                    RuntimeErr::Internal(
-                                        "Failed to insert into statistic table".to_string(),
-                                    ),
+                                return Err(BackendError::BackendError(format!(
+                                    "failed to insert statistic {:?} into statistic table",
+                                    stat
                                 )))
                             }
                         }
@@ -486,8 +483,9 @@ impl CostModelStorageLayer for BackendManager {
             .one(&self.db)
             .await?;
         if expr_exists.is_none() {
-            return Err(BackendError::Database(DbErr::RecordNotFound(
-                "ExprId not found in PhysicalExpression table".to_string(),
+            return Err(BackendError::BackendError(format!(
+                "physical expression id {} not found when storing cost",
+                physical_expression_id
             )));
         }
 
@@ -498,8 +496,9 @@ impl CostModelStorageLayer for BackendManager {
             .await
             .unwrap();
         if epoch_exists.is_none() {
-            return Err(BackendError::Database(DbErr::RecordNotFound(
-                "EpochId not found in Event table".to_string(),
+            return Err(BackendError::BackendError(format!(
+                "epoch id {} not found when storing cost",
+                epoch_id
             )));
         }
 

optd-persistent/src/lib.rs

@@ -41,29 +41,21 @@ fn get_sqlite_url(file: &str) -> String {
 
 pub type StorageResult<T> = Result<T, BackendError>;
 
-#[derive(Debug)]
-pub enum CostModelError {
-    // TODO: Add more error types
-    UnknownStatisticType,
-    VersionedStatisticNotFound,
-}
-
 #[derive(Debug)]
 pub enum BackendError {
-    CostModel(CostModelError),
-    Database(DbErr),
-    // TODO: Add other variants as needed for different error types
+    DatabaseError(DbErr),
+    BackendError(String),
 }
 
-impl From<CostModelError> for BackendError {
-    fn from(value: CostModelError) -> Self {
-        BackendError::CostModel(value)
+impl From<String> for BackendError {
+    fn from(value: String) -> Self {
+        BackendError::BackendError(value)
     }
 }
 
 impl From<DbErr> for BackendError {
     fn from(value: DbErr) -> Self {
-        BackendError::Database(value)
+        BackendError::DatabaseError(value)
     }
 }