relationalai 1.0.0a3__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

v0/relationalai/clients/resources/snowflake/use_index_poller.py

@@ -189,6 +189,9 @@ class UseIndexPoller:
         # on every 5th iteration we reset the cdc status, so it will be checked again
         self.should_check_cdc = True
 
+        # Flag to only check data stream health once in the first call
+        self.check_data_stream_health = True
+
         self.wait_for_stream_sync = self.res.config.get(
             "wait_for_stream_sync", WAIT_FOR_STREAM_SYNC
         )
@@ -503,6 +506,7 @@ class UseIndexPoller:
                 "init_engine_async": self.init_engine_async,
                 "language": self.language,
                 "data_freshness_mins": self.data_freshness,
+                "check_data_stream_health": self.check_data_stream_health
             })
 
             request_headers = debugging.add_current_propagation_headers(self.headers)
@@ -535,6 +539,7 @@ class UseIndexPoller:
                 errors = use_index_data.get("errors", [])
                 relations = use_index_data.get("relations", {})
                 cdc_enabled = use_index_data.get("cdcEnabled", False)
+                health_checked = use_index_data.get("healthChecked", False)
                 if self.check_ready_count % ERP_CHECK_FREQUENCY == 0 or not cdc_enabled:
                     self.should_check_cdc = True
                 else:
@@ -542,6 +547,9 @@ class UseIndexPoller:
 
                 if engines and self.init_engine_async:
                     self.init_engine_async = False
+                
+                if self.check_data_stream_health and health_checked:
+                    self.check_data_stream_health = False
 
                 break_loop = False
                 has_stream_errors = False

v0/relationalai/clients/types.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from abc import ABC
 from datetime import datetime
 from typing import Any, Optional, TypedDict
+from typing_extensions import NotRequired
 from pathlib import Path
 from urllib.parse import urlparse
 
@@ -27,6 +28,7 @@ class AvailableModel(TypedDict):
 
 class EngineState(TypedDict):
     name: str
+    type: str
     id: str
     size: str
     state: str
@@ -38,6 +40,9 @@ class EngineState(TypedDict):
     auto_suspend: int|None
     suspends_at: datetime|None
 
+    # Optional JSON settings (engine configuration)
+    settings: NotRequired[dict | None]
+
 class SourceInfo(TypedDict, total=False):
     type: str|None
     state: str

v0/relationalai/errors.py

@@ -1780,7 +1780,7 @@ class SnowflakeRaiAppNotStarted(RAIException):
     def __init__(self, app_name: str):
         self.app_name = app_name
         self.message = f"The RelationalAI app '{app_name}' isn't started."
-        self.name = "The RelationalAI application not started"
+        self.name = "The RelationalAI application isn't running"
         self.content = self.format_message()
 
         super().__init__(self.message, self.name, self.content)
@@ -2436,6 +2436,24 @@ class QueryTimeoutExceededException(RAIException):
         Consider increasing the 'query_timeout_mins' parameter in your configuration file{f' (stored in {self.config_file_path})' if self.config_file_path else ''} to allow more time for query execution.
         """)
 
+class GuardRailsException(RAIException):
+    def __init__(self, progress: dict[str, Any]={}):
+        self.name = "Guard Rails Violation"
+        self.message = "Transaction aborted due to guard rails violation."
+        self.progress = progress
+        self.content = self.format_message()
+        super().__init__(self.message, self.name, self.content)
+
+    def format_message(self):
+        messages = [] if self.progress else [self.message]
+        for task in self.progress.get("tasks", {}).values():
+            for warning_type, warning_data in task.get("warnings", {}).items():
+                messages.append(textwrap.dedent(f"""
+                Relation Name: [yellow]{task["task_name"]}[/yellow]
+                Warning: {warning_type}
+                Message: {warning_data["message"]}
+                """))
+        return "\n".join(messages)
 
 #--------------------------------------------------
 # Azure Exceptions

v0/relationalai/semantics/lqp/algorithms.py

@@ -0,0 +1,173 @@
+from typing import TypeGuard
+from v0.relationalai.semantics.metamodel import ir, factory, types
+from v0.relationalai.semantics.metamodel.visitor import Rewriter, collect_by_type
+from v0.relationalai.semantics.lqp import ir as lqp
+from v0.relationalai.semantics.lqp.types import meta_type_to_lqp
+from v0.relationalai.semantics.lqp.builtins import (
+    has_empty_annotation, has_assign_annotation, has_upsert_annotation,
+    has_monoid_annotation, has_monus_annotation, has_script_annotation,
+    has_algorithm_annotation, has_while_annotation, global_annotation,
+    empty_annotation, assign_annotation, upsert_annotation, monoid_annotation,
+    monus_annotation
+)
+
+# Complex tests for Loopy constructs in the metamodel
+def is_script(task: ir.Task) -> TypeGuard[ir.Sequence]:
+    """ Check if it is a script i.e., a Sequence with @script annotation. """
+    if not isinstance(task, ir.Sequence):
+        return False
+    return has_script_annotation(task)
+
+def is_algorithm_logical(task: ir.Task) -> TypeGuard[ir.Logical]:
+    """ Check if it is an algorithm logical i.e., a Logical task with all subtasks being
+    algorithm scripts. """
+    if not isinstance(task, ir.Logical):
+        return False
+    return all(is_algorithm_script(subtask) for subtask in task.body)
+
+def is_algorithm_script(task: ir.Task) -> TypeGuard[ir.Sequence]:
+    """ Check if it is an algorithm script i.e., a Sequence with @script and @algorithm annotations. """
+    if not isinstance(task, ir.Sequence):
+        return False
+    return is_script(task) and has_algorithm_annotation(task)
+
+def is_while_loop(task: ir.Task) -> TypeGuard[ir.Loop]:
+    """ Check if input is is a while loop i.e., a Loop with @while annotation. """
+    if not isinstance(task, ir.Loop):
+        return False
+    return has_while_annotation(task)
+
+def is_while_script(task: ir.Task) -> TypeGuard[ir.Sequence]:
+    """ Check if input is a while script i.e., a Sequence with @script and @while annotations. """
+    if not isinstance(task, ir.Sequence):
+        return False
+    return is_script(task) and has_while_annotation(task)
+
+# Tools for annotating Loopy constructs
+class LoopyAnnoAdder(Rewriter):
+    """ Rewrites a node by adding the given annotation to all Update nodes. """
+    def __init__(self, anno: ir.Annotation):
+        self.anno = anno
+        super().__init__()
+
+    def handle_update(self, node: ir.Update, parent: ir.Node) -> ir.Update:
+        new_annos = list(node.annotations) + [self.anno]
+        return factory.update(node.relation, node.args, node.effect, new_annos, node.engine)
+
+def mk_global(i: ir.Node):
+    return LoopyAnnoAdder(global_annotation()).walk(i)
+
+def mk_empty(i: ir.Node):
+    return LoopyAnnoAdder(empty_annotation()).walk(i)
+
+def mk_assign(i: ir.Node):
+    return LoopyAnnoAdder(assign_annotation()).walk(i)
+
+def mk_upsert(i: ir.Node, arity: int):
+    return LoopyAnnoAdder(upsert_annotation(arity)).walk(i)
+
+def mk_monoid(i: ir.Node, monoid_type: ir.ScalarType, monoid_op: str, arity: int):
+    return LoopyAnnoAdder(monoid_annotation(monoid_type, monoid_op, arity)).walk(i)
+
+def mk_monus(i: ir.Node, monoid_type: ir.ScalarType, monoid_op: str, arity: int):
+    return LoopyAnnoAdder(monus_annotation(monoid_type, monoid_op, arity)).walk(i)
+
+def construct_monoid(i: ir.Annotation):
+    base_type = None
+    op = None
+    for arg in i.args:
+        if isinstance(arg, ir.ScalarType):
+            base_type = meta_type_to_lqp(arg)
+        elif isinstance(arg, ir.Literal) and arg.type == types.String:
+            op = arg.value
+    assert isinstance(base_type, lqp.Type) and isinstance(op, str), "Failed to get monoid"
+    if op.lower() == "or":
+        return lqp.OrMonoid(meta=None)
+    elif op.lower() == "sum":
+        return lqp.SumMonoid(type=base_type, meta=None)
+    elif op.lower() == "min":
+        return lqp.MinMonoid(type=base_type, meta=None)
+    elif op.lower() == "max":
+        return lqp.MaxMonoid(type=base_type, meta=None)
+    else:
+        assert False, "Failed to get monoid"
+
+# Tools for analyzing Loopy constructs
+def is_logical_instruction(node: ir.Node) -> TypeGuard[ir.Logical]:
+    if not isinstance(node, ir.Logical):
+        return False
+    return any(collect_by_type(ir.Update, node)) and not any(collect_by_type(ir.Sequence, node))
+
+def get_instruction_body_rels(node: ir.Logical) -> set[ir.Relation]:
+    assert is_logical_instruction(node)
+    body: set[ir.Relation] = set()
+    for update in collect_by_type(ir.Lookup, node):
+        body.add(update.relation)
+    return body
+
+def get_instruction_head_rels(node: ir.Logical) -> set[ir.Relation]:
+    assert is_logical_instruction(node)
+    heads: set[ir.Relation] = set()
+    for update in collect_by_type(ir.Update, node):
+        heads.add(update.relation)
+    return heads
+
+# base Loopy instruction: @empty, @assign, @upsert, @monoid, @monus
+def is_instruction(update: ir.Task) -> TypeGuard[ir.Logical]:
+    if not is_logical_instruction(update):
+        return False
+    for u in collect_by_type(ir.Update, update):
+        if (has_empty_annotation(u) or
+            has_assign_annotation(u) or
+            has_upsert_annotation(u) or
+            has_monoid_annotation(u) or
+            has_monus_annotation(u)):
+            return True
+    return False
+
+# update Loopy instruction @upsert, @monoid, @monus
+def is_update_instruction(task: ir.Task) -> TypeGuard[ir.Logical]:
+    if not is_logical_instruction(task):
+        return False
+    for u in collect_by_type(ir.Update, task):
+        if (has_upsert_annotation(u) or
+            has_monoid_annotation(u) or
+            has_monus_annotation(u)):
+            return True
+    return False
+
+def is_empty_instruction(node: ir.Node) -> TypeGuard[ir.Logical]:
+    """ Check if input is an empty Loopy instruction `empty rel = ∅`"""
+    if not is_logical_instruction(node):
+        return False
+    updates = collect_by_type(ir.Update, node)
+    if not any(has_empty_annotation(update) for update in updates):
+        return False
+
+    # At this point, we have the prerequisites for an empty instruction. We check it is
+    # well-formed:
+    # 1. It has only a single @empty Update operation
+    # 2. Has no other operations
+    assert len(updates) == 1, "[Loopy] Empty instruction must have single Update operation"
+    assert len(node.body) == 1, "[Loopy] Empty instruction must have only a single Update operation"
+
+    return True
+
+# Splits a Loopy instruction into its head updates, body lookups, and other body tasks
+def split_instruction(update_logical: ir.Logical) -> tuple[ir.Update,list[ir.Lookup],list[ir.Task]]:
+    assert is_instruction(update_logical)
+    lookups = []
+    update = None
+    others = []
+    for task in update_logical.body:
+        if isinstance(task, ir.Lookup):
+            lookups.append(task)
+        elif isinstance(task, ir.Update):
+            if update is not None:
+                raise AssertionError("[Loopy] Update instruction must have exactly one Update operation")
+            update = task
+        else:
+            others.append(task)
+    assert update is not None, "[Loopy] Update instruction must have exactly one Update operation"
+
+    return update, lookups, others

v0/relationalai/semantics/lqp/builtins.py

@@ -1,4 +1,5 @@
-from v0.relationalai.semantics.metamodel import factory as f
+from typing import TypeGuard
+from v0.relationalai.semantics.metamodel import factory as f, ir, types
 from v0.relationalai.semantics.metamodel.util import FrozenOrderedSet
 from v0.relationalai.semantics.metamodel import builtins
 
@@ -8,9 +9,205 @@ adhoc = f.relation("adhoc", [])
 adhoc_annotation = f.annotation(adhoc, [])
 
 # We only want to emit attributes for a known set of annotations.
-annotations_to_emit = FrozenOrderedSet([
+supported_lqp_annotations = FrozenOrderedSet([
     adhoc.name,
     builtins.function.name,
     builtins.track.name,
     builtins.recursion_config.name,
 ])
+
+# [LoopyIR] Annotations used to mark metamodel IR elements as Loopy constructs.
+# 1. Programming structures:
+#   * @script marks Sequence blocks `begin ... end`
+#   * @algorithm additionally marks the top-level script
+#   * @while marks Loop as a `while(true) {...}`; its sole Task is a @script @while Sequence
+# 2. Base instructions (Update's with derive Effects)
+#   * @global marks instructions that write to a global relation (only used in top-level script)
+#   * @empty marks instructions that initialize relations to an empty relation
+#   * @assign marks instructions that are standard assignments
+#   * @upsert marks instructions that perform in-place upserts
+#   * @monoid marks instructions that perform in-place monoid updates
+#   * @monus marks instructions that perform in-place monus updates
+
+# These tasks require dedicated handling and currently are only supported in LQP.
+
+# Here we only provide basic inspection functions. Functions for creating these annotations
+# and more complex analysis are in the module relationalai.semantics.lqp.algorithms
+
+# Algorithm: for top-level script of an algorithm
+_algorithm_anno_name = "algorithm"
+algorithm = f.relation(_algorithm_anno_name, [])
+
+def algorithm_annotation():
+    return f.annotation(algorithm, [])
+
+def has_algorithm_annotation(node: ir.Node) -> bool:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _algorithm_anno_name:
+            return True
+    return False
+
+# Script: for Sequence blocks (algorithm or while loop)
+_script_anno_name = "script"
+script = f.relation(_script_anno_name, [])
+
+def script_annotation():
+    return f.annotation(script, [])
+
+def has_script_annotation(node: ir.Node) -> bool:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _script_anno_name:
+            return True
+    return False
+
+# While: for a while Loop or its script body (Sequence)
+_while_anno_name = "while"
+while_ = f.relation(_while_anno_name, [])
+
+def while_annotation():
+    return f.annotation(while_, [])
+
+def has_while_annotation(node: ir.Node) -> bool:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _while_anno_name:
+            return True
+    return False
+
+# Global: marks instructions that write to relation that is the result of an algorithm
+_global_anno_name = "global"
+global_ = f.relation(_global_anno_name, [])
+
+def global_annotation():
+    return f.annotation(global_, [])
+
+def has_global_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _global_anno_name:
+            return True
+    return False
+
+# Empty: Initializes a relation to an empty relation
+_empty_anno_name = "empty"
+empty = f.relation(_empty_anno_name, [])
+
+def empty_annotation():
+    return f.annotation(empty, [])
+
+def has_empty_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _empty_anno_name:
+            return True
+    return False
+
+# Assign: overwrites the target relation
+_assign_anno_name = "assign"
+assign = f.relation(_assign_anno_name, [])
+
+def assign_annotation():
+    return f.annotation(assign, [])
+
+def has_assign_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _assign_anno_name:
+            return True
+    return False
+
+# Upsert: In-place update of relation
+_upsert_anno_name = "upsert"
+upsert = f.relation(_upsert_anno_name, [])
+
+def upsert_annotation(arity: int):
+    return f.annotation(upsert, [f.literal(arity, type=types.Int64)])
+
+def has_upsert_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _upsert_anno_name:
+            return True
+    return False
+
+def get_upsert_annotation(i: ir.Update):
+    for anno in i.annotations:
+        if anno.relation.name == _upsert_anno_name:
+            return anno
+    return None
+
+# Monoid: In-place update of relation by another by a monoid operation (e.g. Integer addition)
+_monoid_anno_name = "monoid"
+monoid = f.relation(_monoid_anno_name, [])
+
+def monoid_annotation(monoid_type: ir.ScalarType, monoid_op: str, arity: int):
+    return f.annotation(monoid, [f.literal(arity, type=types.Int64), monoid_type, f.literal(monoid_op, type=types.String)])
+
+def has_monoid_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _monoid_anno_name:
+            return True
+    return False
+
+def get_monoid_annotation(i: ir.Update):
+    for anno in i.annotations:
+        if anno.relation.name == _monoid_anno_name:
+            return anno
+    return None
+
+# Monus: In-place update of relation by another by "subtraction" operation, if it exists (e.g. Integer subtraction)
+_monus_anno_name = "monus"
+monus = f.relation(_monus_anno_name, [])
+
+def monus_annotation(monoid_type: ir.ScalarType, monoid_op: str, arity: int):
+    return f.annotation(monus, [f.literal(arity, type=types.Int64), monoid_type, f.literal(monoid_op, type=types.String)])
+
+def has_monus_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
+    if not hasattr(node, "annotations"):
+        return False
+    annotations = getattr(node, "annotations", [])
+    for anno in annotations:
+        if anno.relation.name == _monus_anno_name:
+            return True
+    return False
+
+def get_monus_annotation(i: ir.Update):
+    for anno in i.annotations:
+        if anno.relation.name == _monus_anno_name:
+            return anno
+    return None
+
+# Get arity from annotation (for @upsert, @monoid, and @monus)
+def get_arity(i: ir.Annotation):
+    for arg in i.args:
+        if isinstance(arg, ir.Literal) and (arg.type == types.Int64 or arg.type == types.Int128 or arg.type == types.Number):
+            return arg.value
+    assert False, "Failed to get arity"
+
+# All Loopy instructions
+loopy_instructions = [
+    empty,
+    assign,
+    upsert,
+    monoid,
+    monus
+]

v0/relationalai/semantics/lqp/executor.py

@@ -12,6 +12,9 @@ from v0.relationalai import debugging
 from v0.relationalai.errors import NonDefaultLQPSemanticsVersionWarning
 from v0.relationalai.semantics.lqp import result_helpers
 from v0.relationalai.semantics.metamodel import ir, factory as f, executor as e
+
+if TYPE_CHECKING:
+    from v0.relationalai.semantics.internal.internal import Model as InternalModel
 from v0.relationalai.semantics.lqp.compiler import Compiler
 from v0.relationalai.semantics.lqp.intrinsics import mk_intrinsic_datetime_now
 from v0.relationalai.semantics.lqp.constructors import mk_transaction
@@ -31,7 +34,9 @@ if TYPE_CHECKING:
 
 # Whenever the logic engine introduces a breaking change in behaviour, we bump this version
 # once the client is ready to handle it.
-DEFAULT_LQP_SEMANTICS_VERSION = "0"
+#
+# [2026-01-09] bumping to 1 to opt-into hard validation errors from the engine
+DEFAULT_LQP_SEMANTICS_VERSION = "1"
 
 class LQPExecutor(e.Executor):
     """Executes LQP using the RAI client."""
@@ -278,10 +283,11 @@ class LQPExecutor(e.Executor):
                 fields.append(f"NULL as \"{name}\"")
                 continue
 
-            colname = f"col{ix:03}"
+            # Get the actual physical column name from column_fields
+            colname = column_fields[ix][0]
             ix += 1
 
-            if colname in sample_keys:
+            if colname.lower() in sample_keys:
                 # Actual column exists in sample
                 fields.append(f"{colname} as \"{name}\"")
             else:
@@ -400,38 +406,15 @@ class LQPExecutor(e.Executor):
         txn_proto = convert_transaction(txn)
         return final_model, export_info, txn_proto
 
-    # TODO (azreika): This should probably be split up into exporting and other processing. There are quite a lot of arguments here...
-    def _process_results(self, task: ir.Task, final_model: ir.Model, raw_results: TransactionAsyncResponse, export_info: Optional[tuple], export_to: Optional[Table], update: bool) -> DataFrame:
-        cols, extra_cols = self._compute_cols(task, final_model)
-
-        df, errs = result_helpers.format_results(raw_results, cols)
-        self.report_errors(errs)
-
-        # Rename columns if wide outputs is enabled
-        if self.wide_outputs and len(cols) - len(extra_cols) == len(df.columns):
-            df.columns = cols[: len(df.columns)]
-
-        # Process exports
-        if export_to and not self.dry_run:
-            assert cols, "No columns found in the output"
-            assert isinstance(raw_results, TransactionAsyncResponse) and raw_results.transaction, "Invalid transaction result"
-
-            result_cols = export_to._col_names
-
-            if result_cols is not None:
-                assert all(col in result_cols or col in extra_cols for col in cols)
-            else:
-                result_cols = [col for col in cols if col not in extra_cols]
-            assert result_cols
-
-            assert export_info, "Export info should be populated if we are exporting results"
-            self._export(raw_results.transaction['id'], export_info, export_to, cols, result_cols, update)
-
-        return self._postprocess_df(self.config, df, extra_cols)
-
-    def execute(self, model: ir.Model, task: ir.Task, format: Literal["pandas", "snowpark"] = "pandas",
-                export_to: Optional[Table] = None,
-                update: bool = False, meta: dict[str, Any] | None = None) -> DataFrame:
+    def execute(
+        self,
+        model: ir.Model,
+        task: ir.Task,
+        format: Literal["pandas", "snowpark", "csv"] = "pandas",
+        export_to: Optional[Table] = None,
+        update: bool = False,
+        meta: dict[str, Any] | None = None,
+    ) -> DataFrame:
         self.prepare_data()
         previous_model = self._last_model
 
@@ -440,7 +423,7 @@ class LQPExecutor(e.Executor):
         if self.dry_run:
             return DataFrame()
 
-        if format != "pandas":
+        if format == "snowpark":
             raise ValueError(f"Unsupported format: {format}")
 
         # Format meta as headers
@@ -460,8 +443,56 @@ class LQPExecutor(e.Executor):
         assert isinstance(raw_results, TransactionAsyncResponse)
 
         try:
-            return self._process_results(task, final_model, raw_results, export_info, export_to, update)
+            cols, extra_cols = self._compute_cols(task, final_model)
+            df, errs = result_helpers.format_results(raw_results, cols)
+            self.report_errors(errs)
+
+            # Rename columns if wide outputs is enabled
+            if self.wide_outputs and len(cols) - len(extra_cols) == len(df.columns):
+                df.columns = cols[: len(df.columns)]
+
+            if export_to:
+                assert cols, "No columns found in the output"
+                assert raw_results.transaction, "Invalid transaction result"
+                assert export_info, "Export info should be populated if we are exporting results"
+                result_cols = export_to._col_names
+                if result_cols is not None:
+                    assert all(col in result_cols or col in extra_cols for col in cols)
+                else:
+                    result_cols = [col for col in cols if col not in extra_cols]
+                assert result_cols
+                self._export(raw_results.transaction['id'], export_info, export_to, cols, result_cols, update)
+
+            if format == "csv":
+                if export_info is not None and isinstance(export_info, tuple) and isinstance(export_info[0], str):
+                    return DataFrame([export_info[0]], columns=["path"])
+                else:
+                    raise ValueError("The CSV export was not successful!")
+            
+            return self._postprocess_df(self.config, df, extra_cols)
+
         except Exception as e:
             # If processing the results failed, revert to the previous model.
             self._last_model = previous_model
             raise e
+
+    def export_to_csv(self, model: "InternalModel", query) -> str:
+        ### Exports the result of the given query fragment to a CSV file in
+        ### the Snowflake stage area and returns the path to the CSV file.
+
+        from v0.relationalai.semantics.internal.internal import Fragment, with_source
+        from v0.relationalai.environments import runtime_env
+
+        if not query._select:
+            raise ValueError("Cannot export empty selection to CSV")
+
+        clone = Fragment(parent=query)
+        clone._is_export = True
+        clone._source = runtime_env.get_source_pos()
+        ir_model = model._to_ir()
+        with debugging.span("query", dsl=str(clone), **with_source(clone), meta=clone._meta):
+            query_task = model._compiler.fragment(clone)
+            csv_info = self.execute(ir_model, query_task, format="csv", meta=clone._meta)
+            path = csv_info.at[0, "path"]
+            assert isinstance(path, str)
+            return path

v0/relationalai/semantics/lqp/ir.py

@@ -6,7 +6,6 @@ __all__ = [
     "Declaration",
     "FunctionalDependency",
     "Def",
-    "Loop",
     "Abstraction",
     "Formula",
     "Exists",
@@ -55,6 +54,20 @@ __all__ = [
     "convert_transaction",
     "validate_lqp",
     "construct_configure",
+    "Algorithm",
+    "Script",
+    "Construct",
+    "Loop",
+    "Instruction",
+    "Assign",
+    "Break",
+    "Upsert",
+    "MonoidDef",
+    "MonusDef",
+    "OrMonoid",
+    "MinMonoid",
+    "MaxMonoid",
+    "SumMonoid",
 ]
 
 from lqp.ir import (
@@ -63,7 +76,6 @@ from lqp.ir import (
     Declaration,
     FunctionalDependency,
     Def,
-    Loop,
     Abstraction,
     Formula,
     Exists,
@@ -108,6 +120,20 @@ from lqp.ir import (
     Configure,
     IVMConfig,
     MaintenanceLevel,
+    Algorithm,
+    Script,
+    Construct,
+    Loop,
+    Instruction,
+    Assign,
+    Break,
+    Upsert,
+    MonoidDef,
+    MonusDef,
+    OrMonoid,
+    MinMonoid,
+    MaxMonoid,
+    SumMonoid,
 )
 
 from lqp.emit import (