[query] Consolidate alias query #463

src/agdb/commands_mut.rs

@@ -1,7 +1,4 @@
 pub mod insert_alias;
-pub mod insert_alias_id;
-pub mod insert_alias_id_result;
-pub mod insert_alias_result;
 pub mod insert_edge;
 pub mod insert_index;
 pub mod insert_index_id;
@@ -17,9 +14,6 @@ pub mod remove_node;
 pub mod remove_node_index;
 
 use self::insert_alias::InsertAlias;
-use self::insert_alias_id::InsertAliasId;
-use self::insert_alias_id_result::InsertAliasIdResult;
-use self::insert_alias_result::InsertAliasResult;
 use self::insert_edge::InsertEdge;
 use self::insert_index::InsertIndex;
 use self::insert_index_id::InsertIndexId;
@@ -38,9 +32,6 @@ use self::remove_node_index::RemoveNodeIndex;
 pub enum CommandsMut {
     None,
     InsertAlias(InsertAlias),
-    InsertAliasResult(InsertAliasResult),
-    InsertAliasId(InsertAliasId),
-    InsertAliasIdResult(InsertAliasIdResult),
     InsertEdge(InsertEdge),
     InsertIndex(InsertIndex),
     InsertIndexId(InsertIndexId),
@@ -62,14 +53,29 @@ mod tests {
 
     #[test]
     fn derived_from_debug() {
-        format!("{:?}", CommandsMut::InsertNode(InsertNode {}));
+        format!(
+            "{:?}",
+            CommandsMut::InsertAlias(InsertAlias {
+                id: None,
+                alias: String::new(),
+                result: false
+            })
+        );
     }
 
     #[test]
     fn derived_from_partial_eq() {
         assert_eq!(
-            CommandsMut::InsertNode(InsertNode {}),
-            CommandsMut::InsertNode(InsertNode {})
+            CommandsMut::InsertAlias(InsertAlias {
+                id: None,
+                alias: String::new(),
+                result: false
+            }),
+            CommandsMut::InsertAlias(InsertAlias {
+                id: None,
+                alias: String::new(),
+                result: false
+            })
         );
     }
 }

src/agdb/commands_mut/insert_alias.rs

@@ -2,29 +2,44 @@ use super::remove_alias::RemoveAlias;
 use super::CommandsMut;
 use crate::db::db_context::Context;
 use crate::Db;
+use crate::DbId;
 use crate::QueryError;
+use crate::QueryResult;
 
 #[derive(Debug, PartialEq)]
 pub struct InsertAlias {
+    pub(crate) id: Option<DbId>,
     pub(crate) alias: String,
+    pub(crate) result: bool,
 }
 
 impl InsertAlias {
     pub(crate) fn process(
         &self,
         db: &mut Db,
+        result: &mut QueryResult,
         context: &Context,
     ) -> Result<CommandsMut, QueryError> {
-        if self.alias.is_empty() {
-            return Err(QueryError::from("Empty alias is not allowed"));
+        let undo = insert_alias(db, &self.id.unwrap_or(context.id), &self.alias)?;
+
+        if self.result {
+            result.result += 1;
         }
 
-        db.aliases.insert(&self.alias, &context.id)?;
+        Ok(undo)
+    }
+}
 
-        Ok(CommandsMut::RemoveAlias(RemoveAlias {
-            alias: self.alias.clone(),
-        }))
+fn insert_alias(db: &mut Db, id: &DbId, alias: &String) -> Result<CommandsMut, QueryError> {
+    if alias.is_empty() {
+        return Err(QueryError::from("Empty alias is not allowed"));
     }
+
+    db.aliases.insert(alias, id)?;
+
+    Ok(CommandsMut::RemoveAlias(RemoveAlias {
+        alias: alias.clone(),
+    }))
 }
 
 #[cfg(test)]
@@ -36,7 +51,9 @@ mod tests {
         format!(
             "{:?}",
             InsertAlias {
-                alias: String::new()
+                id: None,
+                alias: String::new(),
+                result: false
             }
         );
     }
@@ -45,10 +62,14 @@ mod tests {
     fn derived_from_partial_eq() {
         assert_eq!(
             InsertAlias {
-                alias: String::new()
+                id: None,
+                alias: String::new(),
+                result: false
             },
             InsertAlias {
-                alias: String::new()
+                id: None,
+                alias: String::new(),
+                result: false
             }
         );
     }

src/agdb/commands_mut/insert_edge.rs

@@ -21,7 +21,7 @@ impl InsertEdge {
     ) -> Result<CommandsMut, QueryError> {
         let (from, to) = self.get_from_to(db)?;
         context.graph_index = db.graph.insert_edge(&from, &to)?;
-        context.id = DbId { id: -db.next_index };
+        context.id = DbId(-db.next_index);
 
         Ok(CommandsMut::RemoveEdgeIndex(RemoveEdgeIndex {
             index: context.graph_index,

src/agdb/commands_mut/insert_index_id.rs

@@ -28,7 +28,7 @@ mod tests {
         format!(
             "{:?}",
             InsertIndexId {
-                id: DbId { id: 0 },
+                id: DbId(0),
                 graph_index: GraphIndex { index: 0 }
             }
         );
@@ -38,11 +38,11 @@ mod tests {
     fn derived_from_partial_eq() {
         assert_eq!(
             InsertIndexId {
-                id: DbId { id: 0 },
+                id: DbId(0),
                 graph_index: GraphIndex { index: 0 }
             },
             InsertIndexId {
-                id: DbId { id: 0 },
+                id: DbId(0),
                 graph_index: GraphIndex { index: 0 }
             }
         );

src/agdb/commands_mut/insert_node.rs

@@ -15,7 +15,7 @@ impl InsertNode {
         context: &mut Context,
     ) -> Result<CommandsMut, QueryError> {
         context.graph_index = db.graph.insert_node()?;
-        context.id = DbId { id: db.next_index };
+        context.id = DbId(db.next_index);
 
         Ok(CommandsMut::RemoveNodeIndex(RemoveNodeIndex {
             index: context.graph_index,

src/agdb/commands_mut/remove_alias.rs

@@ -1,4 +1,4 @@
-use super::insert_alias_id::InsertAliasId;
+use super::insert_alias::InsertAlias;
 use super::CommandsMut;
 use crate::db::db_context::Context;
 use crate::Db;
@@ -18,9 +18,10 @@ impl RemoveAlias {
         if let Some(id) = db.aliases.value(&self.alias)? {
             context.id = id;
             db.aliases.remove_key(&self.alias)?;
-            Ok(CommandsMut::InsertAliasId(InsertAliasId {
-                id: context.id,
+            Ok(CommandsMut::InsertAlias(InsertAlias {
+                id: Some(context.id),
                 alias: self.alias.clone(),
+                result: false,
             }))
         } else {
             Ok(CommandsMut::None)

src/agdb/commands_mut/remove_alias_id.rs

@@ -1,4 +1,4 @@
-use super::insert_alias_id::InsertAliasId;
+use super::insert_alias::InsertAlias;
 use super::CommandsMut;
 use crate::Db;
 use crate::DbId;
@@ -13,9 +13,10 @@ impl RemoveAliasId {
     pub(crate) fn process(&self, db: &mut Db) -> Result<CommandsMut, QueryError> {
         if let Some(alias) = db.aliases.key(&self.id)? {
             db.aliases.remove_value(&self.id)?;
-            Ok(CommandsMut::InsertAliasId(InsertAliasId {
-                id: self.id,
+            Ok(CommandsMut::InsertAlias(InsertAlias {
+                id: Some(self.id),
                 alias,
+                result: false,
             }))
         } else {
             Ok(CommandsMut::None)
@@ -29,14 +30,11 @@ mod tests {
 
     #[test]
     fn derived_from_debug() {
-        format!("{:?}", RemoveAliasId { id: DbId { id: 0 } });
+        format!("{:?}", RemoveAliasId { id: DbId(0) });
     }
 
     #[test]
     fn derived_from_partial_eq() {
-        assert_eq!(
-            RemoveAliasId { id: DbId { id: 0 } },
-            RemoveAliasId { id: DbId { id: 0 } }
-        );
+        assert_eq!(RemoveAliasId { id: DbId(0) }, RemoveAliasId { id: DbId(0) });
     }
 }