Merge pull request #885 from vsbogd/fix-complex-queries

Fix complex queries issue #884

Author: vsbogd

lib/src/space/grounding/mod.rs

@@ -2,10 +2,8 @@
 
 pub mod index;
 
-use crate::*;
 use super::*;
 use crate::atom::*;
-use crate::atom::subexpr::split_expr;
 
 use std::fmt::Debug;
 use std::collections::HashSet;
@@ -15,9 +13,6 @@ pub use index::{ALLOW_DUPLICATION, NO_DUPLICATION};
 
 // Grounding space
 
-/// Symbol to concatenate queries to space.
-pub const COMMA_SYMBOL : Atom = sym!(",");
-
 /// In-memory space which can contain grounded atoms.
 // TODO: Clone is required by C API
 #[derive(Clone)]
@@ -75,7 +70,7 @@ impl<D: DuplicationStrategy> GroundingSpace<D> {
     /// assert_eq!(space.query(&sym!("C")), BindingsSet::empty());
     /// ```
     pub fn add(&mut self, atom: Atom) {
-        //log::debug!("GroundingSpace::add(): self: {:?}, atom: {:?}", self as *const GroundingSpace, atom);
+        log::debug!("GroundingSpace::add: {}, atom: {}", self, atom);
         self.index.insert(atom.clone());
         self.common.notify_all_observers(&SpaceEvent::Add(atom));
     }
@@ -97,7 +92,7 @@ impl<D: DuplicationStrategy> GroundingSpace<D> {
     /// assert_eq!(space.query(&sym!("A")), BindingsSet::empty());
     /// ```
     pub fn remove(&mut self, atom: &Atom) -> bool {
-        //log::debug!("GroundingSpace::remove(): self: {:?}, atom: {:?}", self as *const GroundingSpace, atom);
+        log::debug!("GroundingSpace::remove: {}, atom: {}", self, atom);
         let is_removed = self.index.remove(atom);
         if is_removed {
             self.common.notify_all_observers(&SpaceEvent::Remove(atom.clone()));
@@ -152,42 +147,20 @@ impl<D: DuplicationStrategy> GroundingSpace<D> {
     /// assert_eq!(result, bind_set![{x: sym!("B")}]);
     /// ```
     pub fn query(&self, query: &Atom) -> BindingsSet {
-        match split_expr(query) {
-            // Cannot match with COMMA_SYMBOL here, because Rust allows
-            // it only when Atom has PartialEq and Eq derived.
-            Some((sym @ Atom::Symbol(_), args)) if *sym == COMMA_SYMBOL => {
-                args.fold(BindingsSet::single(),
-                    |mut acc, query| {
-                        let result = if acc.is_empty() {
-                            acc
-                        } else {
-                            acc.drain(0..).flat_map(|prev| -> BindingsSet {
-                                let query = matcher::apply_bindings_to_atom_move(query.clone(), &prev);
-                                let mut res = self.query(&query);
-                                res.drain(0..)
-                                    .flat_map(|next| next.merge(&prev))
-                                    .collect()
-                            }).collect()
-                        };
-                        log::debug!("query: current result: {:?}", result);
-                        result
-                    })
-            },
-            _ => self.single_query(query),
-        }
+        complex_query(query, |query| self.single_query(query))
     }
 
     /// Executes simple `query` without sub-queries on the space.
     fn single_query(&self, query: &Atom) -> BindingsSet {
-        log::debug!("single_query: query: {}", query);
+        log::debug!("GroundingSpace::single_query: {} query: {}", self, query);
         let mut result = BindingsSet::empty();
         let query_vars: HashSet<&VariableAtom> = query.iter().filter_type::<&VariableAtom>().collect();
         for bindings in self.index.query(query) {
             let bindings = bindings.narrow_vars(&query_vars);
             log::trace!("single_query: push result: {}", bindings);
             result.push(bindings);
         }
-        log::debug!("single_query: result: {:?}", result);
+        log::debug!("GroundinSpace::single_query: {} result: {}", self, result);
         result
     }
 
@@ -249,7 +222,7 @@ impl PartialEq for GroundingSpace {
     }
 }
 
-impl Debug for GroundingSpace {
+impl<D: DuplicationStrategy> Debug for GroundingSpace<D> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.name {
             Some(name) => write!(f, "GroundingSpace-{name} ({self:p})"),
@@ -258,7 +231,7 @@ impl Debug for GroundingSpace {
     }
 }
 
-impl Display for GroundingSpace {
+impl<D: DuplicationStrategy> Display for GroundingSpace<D> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.name {
             Some(name) => write!(f, "GroundingSpace-{name}"),

lib/src/space/mod.rs

@@ -9,9 +9,14 @@ use std::rc::{Rc, Weak};
 use std::cell::{RefCell, Ref, RefMut};
 use std::borrow::Cow;
 
+use crate::*;
 use crate::common::FlexRef;
 use crate::atom::*;
 use crate::atom::matcher::{BindingsSet, apply_bindings_to_atom_move};
+use crate::atom::subexpr::split_expr;
+
+/// Symbol to concatenate queries to space.
+pub const COMMA_SYMBOL : Atom = sym!(",");
 
 /// Contains information about space modification event.
 #[derive(Clone, Debug, PartialEq)]
@@ -397,3 +402,32 @@ impl<T: Space> Space for &T {
     }
 }
 
+fn complex_query<F>(query: &Atom, single_query: F) -> BindingsSet
+where
+    F: Fn(&Atom) -> BindingsSet,
+{
+    log::debug!("complex_query: query: {}", query);
+    match split_expr(query) {
+        // Cannot match with COMMA_SYMBOL here, because Rust allows
+        // it only when Atom has PartialEq and Eq derived.
+        Some((sym @ Atom::Symbol(_), args)) if *sym == COMMA_SYMBOL => {
+            args.fold(BindingsSet::single(),
+                |mut acc, query| {
+                    let result = if acc.is_empty() {
+                        acc
+                    } else {
+                        acc.drain(0..).flat_map(|prev| -> BindingsSet {
+                            let query = matcher::apply_bindings_to_atom_move(query.clone(), &prev);
+                            let mut res = single_query(&query);
+                            res.drain(0..)
+                                .flat_map(|next| next.merge(&prev))
+                                .collect()
+                        }).collect()
+                    };
+                    log::debug!("ModuleSpace::query: current result: {}", result);
+                    result
+                })
+        },
+        _ => single_query(query),
+    }
+}

lib/src/space/module.rs

@@ -25,7 +25,11 @@ impl ModuleSpace {
     }
 
     pub fn query(&self, query: &Atom) -> BindingsSet {
-        log::debug!("ModuleSpace::query: {}", query);
+        complex_query(query, |query| self.single_query(query))
+    }
+ 
+    fn single_query(&self, query: &Atom) -> BindingsSet {
+        log::debug!("ModuleSpace::query: {} {}", self, query);
         let mut results = self.main.query(query);
         for dep in &self.deps {
             if let Some(space) = dep.borrow().as_any() {
@@ -42,7 +46,7 @@ impl ModuleSpace {
     }
 
     fn query_no_deps(&self, query: &Atom) -> BindingsSet {
-        log::debug!("ModuleSpace::query_no_deps: {}", query);
+        log::debug!("ModuleSpace::query_no_deps: {} {}", self, query);
         self.main.query(query)
     }
 
@@ -91,3 +95,25 @@ impl SpaceMut for ModuleSpace {
     }
 }
 
+#[cfg(test)]
+mod test {
+    use crate::*;
+    use crate::space::grounding::*;
+    use super::*;
+
+    #[test]
+    fn complex_query_two_subspaces() {
+        let mut a = GroundingSpace::new();
+        a.add(expr!("a" "b"));
+        let mut b = GroundingSpace::new();
+        b.add(expr!("b" "c"));
+
+        let mut main = ModuleSpace::new(GroundingSpace::new());
+        main.add_dep(DynSpace::new(ModuleSpace::new(a)));
+        main.add_dep(DynSpace::new(ModuleSpace::new(b)));
+
+        assert_eq_no_order!(main.query(&expr!("," (a "b") ("b" c))), vec![bind!{ a: sym!("a"), c: sym!("c") }]);
+        assert_eq_no_order!(main.query(&expr!("," ("a" b) (b "c"))), vec![bind!{ b: sym!("b") }]);
+    }
+}
+