relationalai 0.13.2__py3-none-any.whl → 0.13.3__py3-none-any.whl

relationalai/semantics/lqp/utils.py

@@ -3,6 +3,7 @@ from relationalai.semantics.metamodel import ir
 from relationalai.semantics.metamodel.helpers import sanitize
 from relationalai.semantics.metamodel.util import FrozenOrderedSet
 
+from dataclasses import dataclass
 from hashlib import sha256
 from typing import Tuple
 
@@ -43,16 +44,25 @@ class UniqueNames:
         self.id_to_name[id] = name
         return name
 
+@dataclass(frozen=True)
+class ExportDescriptor:
+    relation_id: lqp.RelationId
+    column_name: str
+    column_number: int
+    column_type: lqp.Type
+
 class TranslationCtx:
     def __init__(self, def_names: UniqueNames = UniqueNames()):
         # TODO: comment these fields
         self.def_names = def_names
         self.var_names = UniqueNames()
         self.output_names = UniqueNames()
+        # A counter for break rules generated during translation of while loops
+        self.break_rule_counter = 0
         # Map relation IDs to their original names for debugging and pretty printing.
         self.rel_id_to_orig_name = {}
         self.output_ids: list[tuple[lqp.RelationId, str]] = []
-        self.export_ids: list[tuple[lqp.RelationId, int, lqp.Type]] = []
+        self.export_descriptors: list[ExportDescriptor] = []
 
 def gen_rel_id(ctx: TranslationCtx, orig_name: str, suffix: str = "") -> lqp.RelationId:
     relation_id = lqp.RelationId(id=lqp_hash(orig_name + suffix), meta=None)

relationalai/semantics/lqp/validators.py

@@ -6,6 +6,11 @@ CompilableType = Union[
     ir.Logical,
     ir.Union,
 
+    # Loops
+    ir.Loop,
+    ir.Sequence,
+    ir.Break,
+
     # Formulas
     ir.Lookup,
     ir.Exists,
@@ -36,7 +41,7 @@ def assert_valid_input(model: ir.Model) -> None:
 
 def _assert_valid_subtask(task: ir.Task) -> None:
     # TODO: assert what subtasks should look like
-    assert isinstance(task, ir.Logical), f"expected logical task, got {type(task)}"
+    assert isinstance(task, (ir.Logical, ir.Sequence)), f"expected logical task, got {type(task)}"
     _assert_task_compilable(task)
 
 def _assert_task_compilable(task: ir.Task) -> None:
@@ -51,6 +56,14 @@ def _assert_task_compilable(task: ir.Task) -> None:
         assert_valid_update(task)
         effect = task.effect
         assert effect == ir.Effect.derive, "only derive supported at the moment"
+    elif isinstance(task, ir.Sequence):
+        assert any(anno.relation.name == "script" for anno in task.annotations), "only @script sequences supported at the moment"
+        for subtask in task.tasks:
+            _assert_task_compilable(subtask)
+    elif isinstance(task, ir.Loop):
+        assert isinstance(task.body, ir.Sequence), f"expected loop body to be a sequence, got {type(task.body)}"
+        for subtask in task.body.tasks:
+            _assert_task_compilable(subtask)
 
 def assert_valid_update(update: ir.Update) -> None:
     effect = update.effect

relationalai/semantics/metamodel/builtins.py

@@ -474,7 +474,8 @@ external = f.relation("external", [])
 external_annotation = f.annotation(external, [])
 
 # indicates an output is meant to be exported
-export = f.relation("export", [])
+export = f.relation("export", [f.input_field("fqn", types.String)])
+# convenience for when there are no arguments (this is deprecated as fqn should always be used)
 export_annotation = f.annotation(export, [])
 
 # indicates this relation is a concept population

relationalai/semantics/metamodel/compiler.py

@@ -21,7 +21,8 @@ class Compiler():
             for p in self.passes:
                 with debugging.span(p.name) as span:
                     model = p.rewrite(model, options)
-                    span["metamodel"] = str(model.root)
+                    if debugging.DEBUG:
+                        span["metamodel"] = str(model.root)
                 p.reset()
         return model
 

relationalai/semantics/metamodel/dependency.py

@@ -31,6 +31,8 @@ class DependencyInfo():
     parent: dict[int, ir.Task] = field(default_factory=dict)
     # keep track of replacements that were made during a rewrite
     replacements: dict[int, ir.Task] = field(default_factory=dict)
+    # keep track of which logicals are effectful
+    effectful: set[int] = field(default_factory=set)
 
     def task_inputs(self, node: ir.Task) -> Optional[OrderedSet[ir.Var]]:
         """ The input variables for this task, if any. """
@@ -165,7 +167,7 @@ class Cluster():
         # this is a binders cluster, which is a candidate to being merged
         self.mergeable = not self.required and isinstance(task, helpers.BINDERS)
         # this is a cluster that will only hold an effect
-        self.effectful = isinstance(task, helpers.EFFECTS)
+        self.effectful = isinstance(task, helpers.EFFECTS) or task.id in info.effectful
         # this is a cluster that will only hold a composite
         self.composite = isinstance(task, helpers.COMPOSITES)
         # content is either a single task or a set of tasks
@@ -374,7 +376,6 @@ class DependencyAnalysis(visitor.Visitor):
     def __init__(self, info: DependencyInfo):
         self.info = info
 
-
     def enter(self, node: ir.Node, parent: Optional[ir.Node]=None):
         # keep track of parents of all nodes
         if parent and isinstance(parent, ir.Task):
@@ -456,7 +457,7 @@ class DependencyAnalysis(visitor.Visitor):
             # if c1 has an effect and c2 is a composite without hoisted variables or with a
             # hoisted variable that does not have a default (it is a plain var), then c2
             # behaves like a filter and c1 depends on it.
-            if c1.effectful and c2.composite:
+            if c1.effectful and c2.composite and not c2.effectful:
                 task = c2.content.some()
                 assert(isinstance(task, helpers.COMPOSITES))
                 if not task.hoisted:
@@ -608,6 +609,10 @@ class BindingAnalysis(visitor.Visitor):
         else:
             map[key.id].add(val)
 
+    def leave(self, node: ir.Node, parent: Optional[ir.Node]=None):
+        if parent and node.id in self.info.effectful:
+            self.info.effectful.add(parent.id)
+        return super().leave(node, parent)
 
     #
     # Composite tasks
@@ -768,6 +773,8 @@ class BindingAnalysis(visitor.Visitor):
 
 
     def visit_update(self, node: ir.Update, parent: Optional[ir.Node]):
+        assert parent is not None
+        self.info.effectful.add(parent.id)
         # register variables being used as arguments to the update, it's always considered an input
         for v in helpers.vars(node.args):
             self.input(node, v)
@@ -816,6 +823,8 @@ class BindingAnalysis(visitor.Visitor):
 
 
     def visit_output(self, node: ir.Output, parent: Optional[ir.Node]):
+        assert parent is not None
+        self.info.effectful.add(parent.id)
         # register variables being output, they always considered an input to the task
         for v in helpers.output_vars(node.aliases):
             self.input(node, v)

relationalai/semantics/metamodel/executor.py

@@ -1,15 +1,21 @@
 from __future__ import annotations
 
 from pandas import DataFrame
-from typing import Any, Union, Tuple, Literal
+from typing import Any, Union, Tuple, Literal, TYPE_CHECKING
 
 from relationalai.clients.config import Config
 from relationalai.semantics.metamodel import Model, Task, ir
 from relationalai.semantics.metamodel.visitor import collect_by_type
+if TYPE_CHECKING:
+    from relationalai.semantics.internal.internal import Model as InternalModel
+
 from .util import NameCache
 
 import rich
 
+# global flag to suppress type errors from being printed
+SUPPRESS_TYPE_ERRORS = False
+
 class Executor():
     """ Interface for an object that can execute the program specified by a model. """
     def execute(self, model: Model, task:Task, format:Literal["pandas", "snowpark"]="pandas") -> Union[DataFrame, Any]:
@@ -59,3 +65,7 @@ class Executor():
                 if col in df.columns:
                     df = df.drop(col, axis=1)
         return df
+
+    def export_to_csv(self, model: "InternalModel", query) -> str:
+        ### Only implemented in the LQP executor for now.
+        raise NotImplementedError(f"export_to_csv is not supported by {type(self).__name__}")

relationalai/semantics/metamodel/factory.py

@@ -277,8 +277,8 @@ def for_all(vars: PySequence[ir.Var], task: ir.Task, engine: Optional[ir.Engine]
 #
 
 # loops body until a break condition is met
-def loop(iter: ir.Var, body: ir.Task, hoisted: PySequence[ir.VarOrDefault]=[], engine: Optional[ir.Engine]=None, annos: PySequence[ir.Annotation]=[]):
-    return ir.Loop(engine, tuple(hoisted), iter, body, FrozenOrderedSet(annos))
+def loop(body: ir.Task, iter: PySequence[ir.Var]=[],  hoisted: PySequence[ir.VarOrDefault]=[], concurrency:int=1, engine: Optional[ir.Engine]=None, annos: PySequence[ir.Annotation]=[]):
+    return ir.Loop(engine, tuple(hoisted), tuple(iter), body, concurrency, FrozenOrderedSet(annos))
 
 def break_(check: ir.Task, engine: Optional[ir.Engine]=None, annos: PySequence[ir.Annotation]=[]):
     return Break(check, engine, annos)

relationalai/semantics/metamodel/helpers.py

@@ -24,6 +24,13 @@ def sanitize(name:str) -> str:
 # Checks
 #--------------------------------------------------
 
+def is_export(node: ir.Node):
+    """ Whether this node is an export output. """
+    return isinstance(node, ir.Output) and (
+        builtins.export_annotation in node.annotations or
+        any(annotation.relation == builtins.export for annotation in node.annotations)
+    )
+
 def is_concept_lookup(node: ir.Lookup|ir.Relation):
     """ Whether this task is a concept lookup. """
     if isinstance(node, ir.Lookup) and is_concept_lookup(node.relation):

relationalai/semantics/metamodel/ir.py

@@ -427,8 +427,9 @@ class Loop(Task):
     """Execute the body in a loop, incrementing the iter variable, until a break sub-task in
     the body succeeds."""
     hoisted: Tuple[VarOrDefault, ...]
-    iter: Var
+    iter: Tuple[Var, ...]
     body: Task
+    concurrency: int = 1
     annotations:FrozenOrderedSet[Annotation] = annotations_field()
 
 @acceptor
@@ -856,7 +857,7 @@ class Printer(BasePrinter):
 
         # Iteration (Loops)
         elif isinstance(node, Loop):
-            self.print_hoisted(depth, f"Loop ⇓[{self.value_to_string(node.iter)}]{annos_str}", node.hoisted)
+            self.print_hoisted(depth, f"Loop ⇓[{', '.join([self.value_to_string(v) for v in node.iter])}] concurrency={node.concurrency} {annos_str}", node.hoisted)
             self.pprint(node.body, depth + 1, print_ids=print_ids)
 
         elif isinstance(node, Break):

relationalai/semantics/metamodel/rewrite/dnf_union_splitter.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from relationalai.semantics.metamodel import ir
 from relationalai.semantics.metamodel.compiler import Pass
 from relationalai.semantics.metamodel.visitor import Visitor, Rewriter
-from relationalai.semantics.metamodel.util import OrderedSet
+from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
 from relationalai.semantics.metamodel import helpers, factory as f
 from typing import Optional, Any
 
@@ -106,6 +106,7 @@ class DNFExtractor(Visitor):
         # The logical that contains the output.
         # The assumption for the IR at this point is that there is only one output.
         self.output_logical: Optional[ir.Logical] = None
+        self.output_keys: OrderedSet[ir.Var] = ordered_set()
         self.active_negations: list[ir.Not] = []
         # Nodes that have to split into multiple similar nodes, depending on the changes
         # of sub-nodes.
@@ -120,6 +121,8 @@ class DNFExtractor(Visitor):
             if any(isinstance(x, ir.Output) for x in node.body):
                 assert not self.output_logical, "multiple outputs"
                 self.output_logical = node
+                output_node = next(x for x in node.body if isinstance(x, ir.Output))
+                self.output_keys = helpers.collect_vars(output_node)
 
         elif isinstance(node, ir.Not):
             self.active_negations.append(node)
@@ -168,29 +171,36 @@ class DNFExtractor(Visitor):
               self.output_logical and
               len(self.active_negations) % 2 == 0 and
               len(node.tasks) > 1):
-            # We split the union when there is a branch with vars "X,Y" and another with "X,Z"
-            # If some branches have vars "X, Y, Z" and others have "X, Y" or "Y, Z" we don't split
+            # We split the union when there are vars not present in all branches that are
+            # present in the output keys. If vars are not in output keys then they act as
+            # filters only and do not require splitting.
             should_split = False
-            all_vars = helpers.collect_vars(node.tasks[0])
-            for t in node.tasks[1:]:
-                vars = helpers.collect_vars(t)
-                curr_intersection = vars.get_set().intersection(all_vars.get_set())
-                should_split |= not (curr_intersection == vars.get_set() or curr_intersection == all_vars.get_set())
-                if should_split:
-                    replacements:list[ir.Task] = []
-                    for t in node.tasks:
-                        # If some branch should already be replaced, we flatten all the replacements here.
-                        if t in self.replaced_by:
-                            replacements.extend(self.replaced_by[t])
-                        else:
-                            replacements.append(t)
-                    self.replaced_by[node] = replacements
-                    self.should_split.add(parent)
-                    break
-                all_vars.update(vars)
+            all_vars = helpers.collect_vars(node).get_set()
+            all_vars &= self.output_keys.get_set()
+
+            if all_vars:
+                for t in node.tasks:
+                    vars = helpers.collect_vars(t).get_set()
+                    curr_intersection = vars.intersection(all_vars)
+                    if curr_intersection != all_vars:
+                        should_split = True
+                        break
+
+            if should_split:
+                replacements:list[ir.Task] = []
+                for t in node.tasks:
+                    # If some branch should already be replaced, we flatten all
+                    # the replacements here.
+                    if t in self.replaced_by:
+                        replacements.extend(self.replaced_by[t])
+                    else:
+                        replacements.append(t)
+                self.replaced_by[node] = replacements
+                self.should_split.add(parent)
 
         if isinstance(node, ir.Logical) and node == self.output_logical:
             self.output_logical = None
+            self.output_keys = ordered_set()
 
         return node
 

relationalai/semantics/metamodel/rewrite/flatten.py

@@ -13,7 +13,8 @@ class Flatten(Pass):
     """
     Traverses the model's root to flatten it as much as possible. The result of this pass is
     a Logical root where all nested tasks that represent a rule in Rel are extracted to the
-    top level.
+    top level. Additionally, any Sequence is promoted to the top level Logical (but
+    encapsulated by a Logical).
 
     - nested logical with updates becomes a top-level logical (a rule)
 
@@ -122,6 +123,35 @@ class Flatten(Pass):
             Logical
                 lookup tmp2
                 output
+
+    - a Sequence is promoted to the top level Logical, encapsulated by a Logical:
+    From:
+        Logical
+            Logical
+                lookup
+                derive foo
+            Sequence
+                Logical
+                    ...
+                Loop
+                    Sequence
+                        ...
+                Logical
+                    ...
+    To:
+        Logical
+            Logical
+                lookup
+                derive foo
+            Logical
+                Sequence
+                    Logical
+                        ...
+                    Loop
+                        Sequence
+                            ...
+                    Logical
+                        ...
     """
 
     def __init__(self, use_sql: bool=False):
@@ -181,11 +211,8 @@ class Flatten(Pass):
     def handle(self, task: ir.Task, ctx: Context) -> Flatten.HandleResult:
         if isinstance(task, ir.Logical):
             return self.handle_logical(task, ctx)
-        elif isinstance(task, ir.Union) and (task.hoisted or self._use_sql):
-            # Only flatten Unions which hoist variables. If there are no hoisted variables,
-            # then the Union acts as a filter, and it can be inefficient to flatten it.
-            #
-            # However, for the SQL backend, we always need to flatten Unions for correct SQL
+        elif isinstance(task, ir.Union) and self._use_sql:
+            # The SQL backend needs to flatten Unions for correct SQL
             # generation.
             return self.handle_union(task, ctx)
         elif isinstance(task, ir.Match):
@@ -194,6 +221,8 @@ class Flatten(Pass):
             return self.handle_require(task, ctx)
         elif isinstance(task, ir.Not):
             return self.handle_not(task, ctx)
+        elif isinstance(task, ir.Sequence):
+            return self.handle_sequence(task, ctx)
         else:
             return Flatten.HandleResult(task)
 
@@ -253,9 +282,9 @@ class Flatten(Pass):
 
             for output in groups["outputs"]:
                 assert(isinstance(output, ir.Output))
-                new_body = info.task_dependencies(output)
-                new_body.update(ctx.extra_tasks)
-                new_body.add(output)
+                new_body = OrderedSet.from_iterable(t.clone() for t in info.task_dependencies(output))
+                new_body.update(t.clone() for t in ctx.extra_tasks)
+                new_body.add(output.clone())
                 ctx.rewrite_ctx.top_level.append(ir.Logical(task.engine, task.hoisted, tuple(new_body), task.annotations))
 
             return Flatten.HandleResult(None)
@@ -263,9 +292,9 @@ class Flatten(Pass):
         # if there are updates, extract as a new top level rule
         if groups["updates"]:
             # add task dependencies to the body
-            body.prefix(ctx.info.task_dependencies(task))
+            body.prefix(t.clone() for t in ctx.info.task_dependencies(task))
             # potentially add context extra tasks
-            body.update(ctx.extra_tasks)
+            body.update(t.clone() for t in ctx.extra_tasks)
             ctx.rewrite_ctx.top_level.append(ir.Logical(task.engine, task.hoisted, tuple(body), task.annotations))
             return Flatten.HandleResult(None)
 
@@ -278,7 +307,7 @@ class Flatten(Pass):
             agg = cast(ir.Aggregate, groups["aggregates"].some())
 
             # add agg dependencies to the body
-            body.prefix(ctx.info.task_dependencies(agg))
+            body.prefix(t.clone() for t in ctx.info.task_dependencies(agg))
 
             # extract a new logical for the aggregate, exposing aggregate group-by and results
             exposed_vars = OrderedSet.from_iterable(list(agg.group) + helpers.aggregate_outputs(agg))
@@ -298,7 +327,7 @@ class Flatten(Pass):
             rank = cast(ir.Rank, groups["ranks"].some())
 
             # add rank dependencies to the body
-            body.prefix(ctx.info.task_dependencies(rank))
+            body.prefix(t.clone() for t in ctx.info.task_dependencies(rank))
             # for rank, we sort by the args, but the result includes the keys to preserve bag semantics.
             exposed_vars_raw = list(rank.projection) + list(rank.group) + list(rank.args) +[rank.result]
             # deduplicate vars
@@ -487,6 +516,14 @@ class Flatten(Pass):
                 task.annotations
             ))
 
+    def handle_sequence(self, task: ir.Sequence, ctx: Context):
+        new_logical = f.logical(
+            body = [task],
+            engine = task.engine
+        )
+        ctx.rewrite_ctx.top_level.append(new_logical)
+        return Flatten.HandleResult(None)
+
 #--------------------------------------------------
 # Helpers
 #--------------------------------------------------

relationalai/semantics/metamodel/rewrite/format_outputs.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import Tuple
 
-from relationalai.semantics.metamodel import builtins, ir, factory as f, types, visitor
+from relationalai.semantics.metamodel import builtins, ir, factory as f, types, visitor, helpers
 from relationalai.semantics.metamodel.compiler import Pass, group_tasks
 from relationalai.semantics.metamodel.util import OrderedSet
 from relationalai.semantics.metamodel.util import FrozenOrderedSet
@@ -63,7 +63,7 @@ def adjust_outputs(task: ir.Logical, outputs: OrderedSet[ir.Task], wide_outputs:
                 # Remove the original output. This is replaced by per-column outputs below
                 body.remove(output)
 
-                is_export = builtins.export_annotation in output.annotations
+                is_export = helpers.is_export(output)
 
                 # Generate an output for each "column"
                 # output looks like def output(:cols, :col000, key0, key1, value):
@@ -100,7 +100,13 @@ def _generate_output_column(output: ir.Output, idx: int, alias: tuple[str, ir.Va
         (not is_primitive(alias[1].type) or alias[1].type == types.Hash)):
 
         uuid = f.var(f"{alias[0]}_{idx}_uuid", types.String)
-        aliases.append((uuid.name, uuid))
+
+        if not is_primitive(alias[1].type):
+            # For non-primitive types, we keep the original alias
+            aliases.append((alias[0], uuid))
+        else:
+            # For Hash types, we use the uuid name as alias
+            aliases.append((uuid.name, uuid))
 
         return [
             ir.Lookup(None, builtins.uuid_to_string, (alias[1], uuid)),

relationalai/semantics/metamodel/typer/checker.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from typing import Optional, List, Union as PyUnion, Tuple, cast
 
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
-from relationalai.semantics.metamodel import ir, types, visitor, compiler
+from relationalai.semantics.metamodel import ir, types, visitor, compiler, executor
 import rich
 
 
@@ -39,7 +39,8 @@ class CheckEnv:
 
     def _complain(self, node: ir.Node, msg: str):
         """Report an error."""
-        self.diags.append(CheckError(msg, node))
+        if not executor.SUPPRESS_TYPE_ERRORS:
+            self.diags.append(CheckError(msg, node))
 
 
 @dataclass
@@ -306,8 +307,9 @@ class CheckModel(visitor.DAGVisitor):
         for x in node.hoisted:
             if not CheckModel._variable_occurs_in(x, node.body):
                 self.env._complain(node, f"Variable {ir.node_to_string(x).strip()} is hoisted but not used in the body of {ir.node_to_string(node).strip()}.")
-        if not CheckModel._variable_occurs_in(node.iter, node.body):
-            self.env._complain(node, f"Variable {node.iter} is the loop iterator but is not used in the body of {ir.node_to_string(node).strip()}.")
+        for iter_var in node.iter:
+            if not CheckModel._variable_occurs_in(iter_var, node.body):
+                self.env._complain(node, f"Variable {iter_var} is the loop iterator but is not used in the body of {ir.node_to_string(node).strip()}.")
         return super().visit_loop(node, parent)
 
     def visit_update(self, node: ir.Update, parent: Optional[ir.Node]=None):

relationalai/semantics/metamodel/typer/typer.py

@@ -6,7 +6,7 @@ import datetime
 from decimal import Decimal as PyDecimal
 from typing import Optional, Union, Tuple
 from relationalai import debugging
-from relationalai.semantics.metamodel import builtins, helpers, ir, types, visitor, compiler, factory as f
+from relationalai.semantics.metamodel import builtins, helpers, ir, types, visitor, compiler, factory as f, executor
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
 import rich
 import sys
@@ -1361,9 +1361,6 @@ class Replacer(visitor.Rewriter):
 # Typer pass
 #--------------------------------------------------
 
-# global flag to suppress type errors from being printed
-SUPPRESS_TYPE_ERRORS = False
-
 class InferTypes(compiler.Pass):
     def __init__(self):
         super().__init__()
@@ -1392,7 +1389,7 @@ class InferTypes(compiler.Pass):
         with debugging.span("type.replace"):
             final = Replacer(w.net).walk(model)
 
-        if not SUPPRESS_TYPE_ERRORS:
+        if not executor.SUPPRESS_TYPE_ERRORS:
             for err in w.net.errors:
                 rich.print(str(err), file=sys.stderr)
 

relationalai/semantics/metamodel/visitor.py

@@ -466,7 +466,8 @@ class Visitor(GenericVisitor[None]):
             self._walk_engine(node.engine, node)
         for h in node.hoisted:
             self._walk_var_or_default(h, node)
-        self._walk_var(node.iter, node)
+        for iter in node.iter:
+            self._walk_var(iter, node)
         self._walk_node(node.body, node)
         for a in node.annotations:
             self._walk_node(a, node)
@@ -935,9 +936,9 @@ class Rewriter():
     #
     def handle_loop(self, node: ir.Loop, parent: ir.Node):
         hoisted = rewrite_list(ir.VarOrDefault, lambda n: self.walk(n, node), node.hoisted)
-        iter_val = self.walk(node.iter, node)
+        iter = rewrite_list(ir.Var, lambda n: self.walk(n, node), node.iter)
         body = self.walk(node.body, node)
-        return node.reconstruct(node.engine, hoisted, iter_val, body, node.annotations)
+        return node.reconstruct(node.engine, hoisted, iter, body, node.concurrency, node.annotations)
 
     def handle_break(self, node: ir.Break, parent: ir.Node):
         check = self.walk(node.check, node)

relationalai/semantics/reasoners/optimization/solvers_dev.py

@@ -333,7 +333,7 @@ class SolverModelDev:
         executor.execute_raw(textwrap.dedent(f"""
         def delete[:{self.point._name}]: {self.point._name}
         def insert(:{self.point._name}, var, val): {self.points._name}(int128[{i}], var, val)
-        """), readonly=False)
+        """))
         return None
 
     # print summary of the solver result

relationalai/semantics/reasoners/optimization/solvers_pb.py

@@ -599,7 +599,7 @@ class SolverModelPB:
         }}]}}
         """)
 
-        executor.execute_raw(export_rel, readonly=False, query_timeout_mins=query_timeout_mins)
+        executor.execute_raw(export_rel, query_timeout_mins=query_timeout_mins)
 
     def _import_solver_results_from_csv(
         self,
@@ -695,7 +695,7 @@ class SolverModelPB:
         }}
         """)
 
-        executor.execute_raw(load_and_extract_rel, readonly=False, query_timeout_mins=query_timeout_mins)
+        executor.execute_raw(load_and_extract_rel, query_timeout_mins=query_timeout_mins)
 
     def _export_model_to_protobuf(
         self,
@@ -791,7 +791,6 @@ class SolverModelPB:
 
         executor.execute_raw(
             textwrap.dedent(extract_rel) + textwrap.dedent(insert_points_relation),
-            readonly=False,
             query_timeout_mins=query_timeout_mins
         )
 
@@ -929,7 +928,7 @@ class SolverModelPB:
         def delete[:{self.point._name}]: {self.point._name}
         def insert(:{self.point._name}, variable, value): {self.points._name}(int128[{point_index}], variable, value)
         """
-        executor.execute_raw(textwrap.dedent(load_point_relation), readonly=False)
+        executor.execute_raw(textwrap.dedent(load_point_relation))
 
     def summarize_result(self) -> Any:
         """Print solver result summary.

relationalai/semantics/rel/compiler.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import Any, Iterable, Sequence as PySequence, cast, Tuple, Union
 from dataclasses import dataclass, field
 from decimal import Decimal as PyDecimal
@@ -843,7 +844,7 @@ class ModelToRel:
 
     def _effect_name(self, n: ir.Task):
         """ Return the name to be used for the effect (e.g. the relation name, output, etc). """
-        if isinstance(n, ir.Output) and bt.export_annotation in n.annotations:
+        if helpers.is_export(n):
             return "Export_Relation"
         elif isinstance(n, ir.Output):
             return "output"

relationalai/semantics/rel/executor.py

@@ -355,8 +355,9 @@ class RelExecutor(e.Executor):
 
     # NOTE(coey): this is added temporarily to support executing Rel for the solvers library in EA.
     # It can be removed once this is no longer needed by the solvers library.
-    def execute_raw(self, raw_rel:str, readonly:bool=True, query_timeout_mins:int|None=None) -> DataFrame:
-        raw_results = self.resources.exec_raw(self.database, self.engine, raw_rel, readonly, nowait_durable=True, query_timeout_mins=query_timeout_mins)
+    def execute_raw(self, raw_rel:str, query_timeout_mins:int|None=None) -> DataFrame:
+        # NOTE intentionally hard-coding to read-only=False, because read-only Rel queries are deprecated.
+        raw_results = self.resources.exec_raw(self.database, self.engine, raw_rel, False, nowait_durable=True, query_timeout_mins=query_timeout_mins)
         df, errs = result_helpers.format_results(raw_results, None, generation=Generation.QB)  # Pass None for task parameter
         self.report_errors(errs)
         return df