update properties to add extensional interactions between them

alpaylan · alpaylan · commit 13442808dd0a · 2025-01-13T14:35:42.000+03:00
diff --git a/simulator/generation/property.rs b/simulator/generation/property.rs
@@ -1,6 +1,6 @@
 use crate::{
     model::{
-        query::{Create, Insert, Predicate, Query, Select},
+        query::{Create, Delete, Insert, Predicate, Query, Select},
         table::Value,
     },
     runner::env::SimulatorEnv,
@@ -35,7 +35,7 @@ pub(crate) enum Property {
         /// The insert query
         insert: Insert,
         /// Additional interactions in the middle of the property
-        interactions: Vec<Query>,
+        queries: Vec<Query>,
         /// The select query
         select: Select,
     },
@@ -55,7 +55,7 @@ pub(crate) enum Property {
         /// The create query
         create: Create,
         /// Additional interactions in the middle of the property
-        interactions: Vec<Query>,
+        queries: Vec<Query>,
     },
 }
 
@@ -70,7 +70,7 @@ impl Property {
         match self {
             Property::InsertSelect {
                 insert,
-                interactions: _, // todo: add extensional interactions
+                queries,
                 select,
             } => {
                 // Check that the row is there
@@ -106,21 +106,34 @@ impl Property {
                     }),
                 });
 
-                vec![
-                    assumption,
-                    Interaction::Query(Query::Insert(insert.clone())),
-                    Interaction::Query(Query::Select(select.clone())),
-                    assertion,
-                ]
+                let mut interactions = Vec::new();
+                interactions.push(assumption);
+                interactions.push(Interaction::Query(Query::Insert(insert.clone())));
+                interactions.extend(queries.clone().into_iter().map(Interaction::Query));
+                interactions.push(Interaction::Query(Query::Select(select.clone())));
+                interactions.push(assertion);
+
+                interactions
             }
             Property::DoubleCreateFailure {
                 create,
-                interactions: _, // todo: add extensional interactions
+                queries,
             } => {
                 let table_name = create.table.name.clone();
+
+                let assumption = Interaction::Assumption(Assertion {
+                    message: "Double-Create-Failure should not be called on an existing table"
+                        .to_string(),
+                    func: Box::new(move |_: &Vec<ResultSet>, env: &SimulatorEnv| {
+                        !env.tables.iter().any(|t| t.name == table_name)
+                    }),
+                });
+
                 let cq1 = Interaction::Query(Query::Create(create.clone()));
                 let cq2 = Interaction::Query(Query::Create(create.clone()));
 
+                let table_name = create.table.name.clone();
+
                 let assertion = Interaction::Assertion(Assertion {
                     message:
                         "creating two tables with the name should result in a failure for the second query"
@@ -136,13 +149,26 @@ impl Property {
                     }),
                 });
 
-                vec![cq1, cq2, assertion]
+                let mut interactions = Vec::new();
+                interactions.push(assumption);
+                interactions.push(cq1);
+                interactions.extend(queries.clone().into_iter().map(Interaction::Query));
+                interactions.push(cq2);
+                interactions.push(assertion);
+
+                interactions
             }
         }
     }
 }
 
-fn remaining(env: &SimulatorEnv, stats: &InteractionStats) -> (f64, f64, f64) {
+pub(crate) struct Remaining {
+    pub(crate) read: f64,
+    pub(crate) write: f64,
+    pub(crate) create: f64,
+}
+
+fn remaining(env: &SimulatorEnv, stats: &InteractionStats) -> Remaining {
     let remaining_read = ((env.opts.max_interactions as f64 * env.opts.read_percent / 100.0)
         - (stats.read_count as f64))
         .max(0.0);
@@ -153,10 +179,14 @@ fn remaining(env: &SimulatorEnv, stats: &InteractionStats) -> (f64, f64, f64) {
         - (stats.create_count as f64))
         .max(0.0);
 
-    (remaining_read, remaining_write, remaining_create)
+    Remaining {
+        read: remaining_read,
+        write: remaining_write,
+        create: remaining_create,
+    }
 }
 
-fn property_insert_select<R: rand::Rng>(rng: &mut R, env: &SimulatorEnv) -> Property {
+fn property_insert_select<R: rand::Rng>(rng: &mut R, env: &SimulatorEnv, remaining: &Remaining) -> Property {
     // Get a random table
     let table = pick(&env.tables, rng);
     // Pick a random column
@@ -181,6 +211,36 @@ fn property_insert_select<R: rand::Rng>(rng: &mut R, env: &SimulatorEnv) -> Prop
         values: vec![row.clone()],
     };
 
+    // Create random queries respecting the constraints
+    let mut queries = Vec::new();
+    // - [x] There will be no errors in the middle interactions. (this constraint is impossible to check, so this is just best effort)
+    // - [x] The inserted row will not be deleted.
+    // - [ ] The inserted row will not be updated. (todo: add this constraint once UPDATE is implemented)
+    // - [ ] The table `t` will not be renamed, dropped, or altered. (todo: add this constraint once ALTER or DROP is implemented)
+    for _ in 0..rng.gen_range(0..3) {
+        let query = Query::arbitrary_from(rng, &(table, remaining));
+        match &query {
+            Query::Delete(Delete {
+                table: t,
+                predicate,
+            }) => {
+                // The inserted row will not be deleted.
+                if t == &table.name && predicate.test(&row, &table) {
+                    continue;
+                }
+            }
+            Query::Create(Create { table: t }) => {
+                // There will be no errors in the middle interactions.
+                // - Creating the same table is an error
+                if t.name == table.name {
+                    continue;
+                }
+            }
+            _ => (),
+        }
+        queries.push(query);
+    }
+
     // Select the row
     let select_query = Select {
         table: table.name.clone(),
@@ -189,40 +249,62 @@ fn property_insert_select<R: rand::Rng>(rng: &mut R, env: &SimulatorEnv) -> Prop
 
     Property::InsertSelect {
         insert: insert_query,
-        interactions: Vec::new(),
+        queries,
         select: select_query,
     }
 }
 
-fn property_double_create_failure<R: rand::Rng>(rng: &mut R, env: &SimulatorEnv) -> Property {
+fn property_double_create_failure<R: rand::Rng>(rng: &mut R, env: &SimulatorEnv, remaining: &Remaining) -> Property {
     // Get a random table
     let table = pick(&env.tables, rng);
     // Create the table
     let create_query = Create {
         table: table.clone(),
     };
 
+    // Create random queries respecting the constraints
+    let mut queries = Vec::new();
+    // The interactions in the middle has the following constraints;
+    // - [x] There will be no errors in the middle interactions.(best effort)
+    // - [ ] Table `t` will not be renamed or dropped.(todo: add this constraint once ALTER or DROP is implemented)
+    for _ in 0..rng.gen_range(0..3) {
+        let query = Query::arbitrary_from(rng, &(table, remaining));
+        match &query {
+            Query::Create(Create { table: t }) => {
+                // There will be no errors in the middle interactions.
+                // - Creating the same table is an error
+                if t.name == table.name {
+                    continue;
+                }
+            }
+            _ => (),
+        }
+        queries.push(query);
+    }
+
     Property::DoubleCreateFailure {
         create: create_query,
-        interactions: Vec::new(),
+        queries,
     }
 }
 
+
+
 impl ArbitraryFrom<(&SimulatorEnv, &InteractionStats)> for Property {
     fn arbitrary_from<R: rand::Rng>(
         rng: &mut R,
         (env, stats): &(&SimulatorEnv, &InteractionStats),
     ) -> Self {
-        let (remaining_read, remaining_write, remaining_create) = remaining(env, stats);
+        let remaining_ = remaining(env, stats);
         frequency(
             vec![
                 (
-                    f64::min(remaining_read, remaining_write),
-                    Box::new(|rng: &mut R| property_insert_select(rng, env)),
+                    f64::min(remaining_.read, remaining_.write),
+                    Box::new(|rng: &mut R| property_insert_select(rng, env, &remaining_)),
                 ),
                 (
-                    remaining_create / 2.0,
-                    Box::new(|rng: &mut R| property_double_create_failure(rng, env)),
+                    remaining_.create / 2.0,
+                    Box::new(|rng: &mut R| property_double_create_failure(rng, env, &remaining_)),
                 ),
             ],
             rng,
diff --git a/simulator/generation/query.rs b/simulator/generation/query.rs
@@ -6,6 +6,7 @@ use crate::model::table::{Table, Value};
 use rand::seq::SliceRandom as _;
 use rand::Rng;
 
+use super::property::Remaining;
 use super::{frequency, pick};
 
 impl Arbitrary for Create {
@@ -87,6 +88,32 @@ impl ArbitraryFrom<Table> for Query {
     }
 }
 
+impl ArbitraryFrom<(&Table, &Remaining)> for Query {
+    fn arbitrary_from<R: Rng>(rng: &mut R, (table, remaining): &(&Table, &Remaining)) -> Self {
+        frequency(
+            vec![
+                (
+                    remaining.create,
+                    Box::new(|rng| Self::Create(Create::arbitrary(rng))),
+                ),
+                (
+                    remaining.read,
+                    Box::new(|rng| Self::Select(Select::arbitrary_from(rng, &vec![*table]))),
+                ),
+                (
+                    remaining.write,
+                    Box::new(|rng| Self::Insert(Insert::arbitrary_from(rng, table))),
+                ),
+                (
+                    0.0,
+                    Box::new(|rng| Self::Delete(Delete::arbitrary_from(rng, table))),
+                ),
+            ],
+            rng,
+        )
+    }
+}
+
 struct CompoundPredicate(Predicate);
 struct SimplePredicate(Predicate);
 
@@ -322,7 +349,6 @@ impl ArbitraryFrom<(&Table, &Vec<Value>)> for Predicate {
 
         // Start building a top level predicate from a true predicate
         let mut result = true_predicates.pop().unwrap();
-        println!("True predicate: {:?}", result);
 
         let mut predicates = true_predicates
             .iter()
diff --git a/simulator/model/query.rs b/simulator/model/query.rs
@@ -20,6 +20,26 @@ impl Predicate {
     pub(crate) fn false_() -> Self {
         Self::Or(vec![])
     }
+
+    pub(crate) fn test(&self, row: &[Value], table: &Table) -> bool {
+        let get_value = |name: &str| {
+            table
+                .columns
+                .iter()
+                .zip(row.iter())
+                .find(|(column, _)| column.name == name)
+                .map(|(_, value)| value)
+        };
+
+        match self {
+            Predicate::And(vec) => vec.iter().all(|p| p.test(row, table)),
+            Predicate::Or(vec) => vec.iter().any(|p| p.test(row, table)),
+            Predicate::Eq(column, value) => get_value(column) == Some(value),
+            Predicate::Neq(column, value) => get_value(column) != Some(value),
+            Predicate::Gt(column, value) => get_value(column).map(|v| v > value).unwrap_or(false),
+            Predicate::Lt(column, value) => get_value(column).map(|v| v < value).unwrap_or(false),
+        }
+    }
 }
 
 impl Display for Predicate {
diff --git a/simulator/model/table.rs b/simulator/model/table.rs
@@ -53,6 +53,22 @@ pub(crate) enum Value {
     Blob(Vec<u8>),
 }
 
+impl PartialOrd for Value {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match (self, other) {
+            (Self::Null, Self::Null) => Some(std::cmp::Ordering::Equal),
+            (Self::Null, _) => Some(std::cmp::Ordering::Less),
+            (_, Self::Null) => Some(std::cmp::Ordering::Greater),
+            (Self::Integer(i1), Self::Integer(i2)) => i1.partial_cmp(i2),
+            (Self::Float(f1), Self::Float(f2)) => f1.partial_cmp(f2),
+            (Self::Text(t1), Self::Text(t2)) => t1.partial_cmp(t2),
+            (Self::Blob(b1), Self::Blob(b2)) => b1.partial_cmp(b2),
+            // todo: add type coercions here
+            _ => None,
+        }
+    }
+}
+
 fn to_sqlite_blob(bytes: &[u8]) -> String {
     format!(
         "X'{}'",
diff --git a/simulator/shrink/plan.rs b/simulator/shrink/plan.rs
@@ -1,4 +1,7 @@
-use crate::{generation::plan::InteractionPlan, runner::execution::Execution};
+use crate::{
+    generation::plan::{Interaction, InteractionPlan, Interactions},
+    runner::execution::Execution,
+};
 
 impl InteractionPlan {
     /// Create a smaller interaction plan by deleting a property
@@ -19,6 +22,23 @@ impl InteractionPlan {
         plan.plan
             .retain(|p| p.uses().iter().any(|t| depending_tables.contains(t)));
 
+        // Remove the extensional parts of the properties
+        for interaction in plan.plan.iter_mut() {
+            if let Interactions::Property(p) = interaction {
+                match p {
+                    crate::generation::property::Property::InsertSelect {
+                        queries,
+                        ..
+                    } |
+                    crate::generation::property::Property::DoubleCreateFailure {
+                        queries,
+                        ..
+                    } => {
+                        queries.clear();
+                    }
+                }
+            }
+        }
         let after = plan.plan.len();
 
         log::info!(
