insertion from test data

src/db/mutation.rs

@@ -61,10 +61,10 @@ impl<'a, 't> Session<'a, 't> {
                 _ => unreachable!()
             }
         }
-        println!("{:?}", kind);
-        println!("{:?}", expr);
-        println!("{:?}", default_kind);
-        println!("{:?}", filters);
+        // println!("{:?}", kind);
+        // println!("{:?}", expr);
+        // println!("{:?}", default_kind);
+        // println!("{:?}", filters);
 
         let mut mutation_manager = MutationManager::new(self, default_kind);
         // Coercion
@@ -293,4 +293,41 @@ mod tests {
         drop(engine);
         let _ = fs::remove_dir_all(db_path);
     }
+
+    #[test]
+    fn test_big_mutation() {
+        let db_path = "_test_big_mutation";
+        let engine = Engine::new(db_path.to_string(), true).unwrap();
+
+        {
+            let mut sess = engine.session().unwrap();
+            let s = fs::read_to_string("test_data/hr.cozo").unwrap();
+            for p in Parser::parse(Rule::file, &s).unwrap() {
+                if p.as_rule() == Rule::EOI {
+                    break;
+                }
+                sess.run_definition(p).unwrap();
+            }
+            sess.commit().unwrap();
+        }
+
+        {
+            let mut sess = engine.session().unwrap();
+            let data = fs::read_to_string("test_data/hr.json").unwrap();
+            let s = format!("insert {};", data);
+            let p = Parser::parse(Rule::file, &s).unwrap().next().unwrap();
+            assert!(sess.run_mutation(p.clone()).is_ok());
+            sess.commit().unwrap();
+            assert!(sess.run_mutation(p.clone()).is_err());
+            sess.rollback().unwrap();
+            let it = sess.txn.iterator(true, &sess.perm_cf);
+            it.to_first();
+            for (k, v) in it.iter() {
+                println!("K: {:?}, V: {:?}", Tuple::new(k), Tuple::new(v));
+            }
+        }
+
+        drop(engine);
+        let _ = fs::remove_dir_all(db_path);
+    }
 }

src/db/plan.rs

@@ -204,7 +204,7 @@ mod tests {
             let s = "from a:Friend, (b:Person)-[:Friend]->(c:Person), x:Person";
             let parsed = Parser::parse(Rule::from_pattern, s).unwrap().next().unwrap();
             assert_eq!(parsed.as_rule(), Rule::from_pattern);
-            sess.parse_from_pattern(parsed);
+            sess.parse_from_pattern(parsed).unwrap();
         }
         drop(engine);
         let _ = fs::remove_dir_all(db_path);

test_data/hr.cozo

@@ -1,50 +1,50 @@
 create node Job {
     *id: Int,
-    title: String,
+    title: Text,
     min_salary: Float,
     max_salary: Float
 }
 
 create node Employee {
     *id: Int,
-    first_name: String,
-    last_name: String,
-    email: String,
-    phone_number: ?String
+    first_name: Text,
+    last_name: Text,
+    email: Text,
+    phone_number: ?Text
 }
 
 create node Dependent {
     *id: Int,
-    first_name: String,
-    last_name: String
+    first_name: Text,
+    last_name: Text
 }
 
 create node Department {
     *id: Int,
-    name: String
+    name: Text
 }
 
 create node Location {
     *id: Int,
-    street_address: String,
-    postal_code: ?String,
-    city: String,
-    state_province: ?String
+    street_address: Text,
+    postal_code: ?Text,
+    city: Text,
+    state_province: ?Text
 }
 
 create node Country {
-    *id: String,
-    name: String
+    *id: Text,
+    name: Text
 }
 
 create node Region {
     *id: Int,
-    name: String
+    name: Text
 }
 
 create edge (Employee)-[HasJob]->(Job) {
     salary: Float,
-    hire_date: String
+    hire_date: Text
 }
 
 create edge (Employee)-[InDepartment]->(Department)
@@ -52,7 +52,7 @@ create edge (Employee)-[InDepartment]->(Department)
 create edge (Employee)-[Manages]->(Employee)
 
 create edge (Employee)-[HasDependent]->(Dependent) {
-    relationship: String
+    relationship: Text
 }
 
 create edge (Department)-[InLocation]->(Location)