relationalai 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

relationalai/semantics/metamodel/dependency.py

@@ -96,8 +96,12 @@ class DependencyInfo():
             # start with the cluster dependencies, because cluster represents the task we
             # care about
             queue.extend(cluster.dependencies)
+            seen = set()
             while queue:
                 cluster = queue.pop()
+                if cluster.id in seen:
+                    continue
+                seen.add(cluster.id)
                 deps.update(cluster.content)
                 queue.extend(cluster.dependencies)
 
@@ -625,13 +629,17 @@ class BindingAnalysis(visitor.Visitor):
                     # TODO: this is similar to what's done below in visit_lookup, modularize
                     if builtins.is_eq(child.relation):
                         x, y = child.args[0], child.args[1]
+                        # Compute input/output vars of the equality
                         if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
-                            grounds.add(x)
+                            # Variable x is potentially grounded by other expressions at
+                            # level in the Logical. If it is, then we should mark it as
+                            # input (which is done later).
+                            potentially_grounded.add((child, x, x))
                         elif not isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                            grounds.add(y)
+                            potentially_grounded.add((child, y, y))
                         elif isinstance(x, ir.Var) and isinstance(y, ir.Var):
                             # mark as potentially grounded, if any is grounded in other atoms then we later ground both
-                            potentially_grounded.add((x, y))
+                            potentially_grounded.add((child, x, y))
                     else:
                         # grounds only outputs
                         for idx, f in enumerate(child.relation.fields):
@@ -654,23 +662,33 @@ class BindingAnalysis(visitor.Visitor):
                 # grounds the output var
                 grounds.add(child.id_var)
 
+        # add child hoisted vars to grounded so that they can be picked up by the children
+        for child in node.body:
+            if isinstance(child, helpers.COMPOSITES):
+                grounds.update(helpers.hoisted_vars(child.hoisted))
+
+        # equalities where both sides are already grounded mean that both sides are input
+        for child, x, y in potentially_grounded:
+            if x in grounds and y in grounds:
+                self.input(child, x)
+                self.input(child, y)
+
         # deal with potentially grounded vars up to a fixpoint
         changed = True
         while changed:
             changed = False
-            for x, y in potentially_grounded:
+            for child, x, y in potentially_grounded:
                 if x in grounds and y not in grounds:
+                    self.input(child, x)
+                    self.output(child, y)
                     grounds.add(y)
                     changed = True
                 elif y in grounds and x not in grounds:
+                    self.input(child, y)
+                    self.output(child, x)
                     grounds.add(x)
                     changed = True
 
-        # add child hoisted vars to grounded so that they can be picked up by the children
-        for child in node.body:
-            if isinstance(child, helpers.COMPOSITES):
-                grounds.update(helpers.hoisted_vars(child.hoisted))
-
         # now visit the children
         self._grounded.append(grounds)
         super().visit_logical(node, parent)
@@ -765,20 +783,25 @@ class BindingAnalysis(visitor.Visitor):
                     self.output(node, arg)
 
         if builtins.is_eq(node.relation):
-            # special case eq because it can be input or output
-            x, y = node.args[0], node.args[1]
-            if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
-                self.output(node, x)
-            elif not isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                self.output(node, y)
-            elif isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                # in this case it's possible that both are outputs (if both are grounded), else both are inputs
+            # Most cases are covered already at the parent level if the equality is part of
+            # a Logical. The remaining cases are when the equality is a child of a
+            # non-Logical, or if its variables are not ground elsewhere in the Logical.
+            if self.info.task_inputs(node) or self.info.task_outputs(node):
+                # already covered
+                pass
+            else:
+                x, y = node.args[0], node.args[1]
                 grounds = self._grounded[-1] if self._grounded else ordered_set()
-                for var in (x, y):
-                    if var in grounds:
-                        self.output(node, var)
+                if isinstance(x, ir.Var):
+                    if x in grounds:
+                        self.input(node, x)
+                    else:
+                        self.output(node, x)
+                if isinstance(y, ir.Var):
+                    if y in grounds:
+                        self.input(node, y)
                     else:
-                        self.input(node, var)
+                        self.output(node, y)
         else:
             # register variables depending on the input flag of the relation bound to the lookup
             for idx, f in enumerate(node.relation.fields):

relationalai/semantics/metamodel/helpers.py

@@ -348,12 +348,13 @@ def clone_task(task: T) -> T:
         # if no childrean were stacked, we rewrote all fields of curr, so we can pop it and rewrite it
         if not stacked_children:
             stack.pop()
-            children = []
-            for f in curr_fields:
-                children.append(from_cache(getattr(curr, f.name)))
-            # create a new prev_node with the cloned children
-            prev_node = curr.__class__(*children)
-            cache[curr.id] = prev_node
+            if curr.id not in cache:
+                children = []
+                for f in curr_fields:
+                    children.append(from_cache(getattr(curr, f.name)))
+                # create a new prev_node with the cloned children
+                prev_node = curr.__class__(*children)
+                cache[curr.id] = prev_node
 
     # the last node we processed is the rewritten original node
     assert(isinstance(prev_node, type(task)))

relationalai/semantics/metamodel/rewrite/extract_nested_logicals.py

@@ -58,10 +58,7 @@ class LogicalExtractor(Rewriter):
         # compute the vars to be exposed by the extracted logical; those are keys (what
         # makes the values unique) + the values (the hoisted variables)
         exposed_vars = ordered_set()
-        # start with all the inputs to this logical as keys
-        # TODO - in the future we can analyze better these inputs to see if we can drop
-        # some and have narrower intermediate relations
-        exposed_vars.update(self.info.task_inputs(logical))
+
         # if there are aggregations, make sure we don't expose the projected and input vars,
         # but expose groupbys
         for child in node.body:

relationalai/semantics/metamodel/rewrite/flatten.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import cast, Optional, TypeVar
 from typing import Tuple
 
-from relationalai.semantics.metamodel import builtins, ir, factory as f, helpers, types, visitor
+from relationalai.semantics.metamodel import builtins, ir, factory as f, helpers, types
 from relationalai.semantics.metamodel.compiler import Pass, group_tasks
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set, NameCache
 from relationalai.semantics.metamodel import dependency
@@ -611,18 +611,6 @@ def set_union(s1: Optional[OrderedSet[T]], s2: Optional[OrderedSet[T]]) -> list:
         return s2.get_list()
     return []
 
-def extractable(t: ir.Task):
-    """
-    Whether this task is a Logical that will be extracted as a top level by this
-    pass, because it has an aggregation, effects, match, union, etc.
-    """
-    extractable_types = (ir.Update, ir.Aggregate, ir.Match, ir.Union, ir.Rank)
-    return isinstance(t, ir.Logical) and len(visitor.collect_by_type(extractable_types, t)) > 0
-
-def extractables(composites: OrderedSet[ir.Task]):
-    """ Filter the set of composites, keeping only the extractable ones. """
-    return list(filter(extractable, composites))
-
 def negate(lookup: ir.Lookup, values: int):
     """
     Return a negation of this reference, where the last `values` arguments are to