relationalai 0.11.3__py3-none-any.whl → 0.11.4__py3-none-any.whl

relationalai/early_access/dsl/bindings/csv.py

@@ -1,5 +1,5 @@
 from io import StringIO
-from typing import Optional
+from typing import Optional, Hashable
 
 import numpy as np
 import pandas as pd
@@ -76,7 +76,7 @@ class BindableCsvColumn(BindableColumn, b.Relationship):
 
 
 class CsvTable(AbstractBindableTable[BindableCsvColumn]):
-    _basic_type_schema: dict[str, str]
+    _basic_type_schema: dict[Hashable, str]
     _csv_data: list[pd.DataFrame]
     _num_rows: int
 

relationalai/semantics/internal/internal.py

@@ -514,11 +514,13 @@ class Producer:
     #--------------------------------------------------
 
     def in_(self, values:list[Any]|Fragment) -> Expression:
+        columns = None
         if isinstance(values, Fragment):
             return self == values
         if not isinstance(values[0], tuple):
             values = [tuple([v]) for v in values]
-        d = data(values)
+            columns = [f"v{i}" for i in range(len(values[0]))]
+        d = data(values, columns)
         return self == d[0]
 
     #--------------------------------------------------
@@ -907,9 +909,9 @@ class Concept(Producer):
                 if python_types_to_concepts.get(v):
                     v = python_types_to_concepts[v]
                 if isinstance(v, Concept):
-                    setattr(self, k, Property(f"{{{self._name}}} has {{{k}:{v._name}}}", short_name=k, model=self._model))
+                    setattr(self, k, Property(f"{{{self._name}}} has {{{k}:{v._name}}}", parent=self, short_name=k, model=self._model))
                 elif isinstance(v, type) and issubclass(v, self._model.Enum): #type: ignore
-                    setattr(self, k, Property(f"{{{self._name}}} has {{{k}:{v._concept._name}}}", short_name=k, model=self._model))
+                    setattr(self, k, Property(f"{{{self._name}}} has {{{k}:{v._concept._name}}}", parent=self, short_name=k, model=self._model))
                 elif isinstance(v, Relationship):
                     self._validate_identifier_relationship(v)
                     setattr(self, k, v)
@@ -1189,6 +1191,7 @@ def is_decimal(concept: Concept) -> bool:
 Concept.builtins["Int"] = Concept.builtins["Int128"]
 Concept.builtins["Integer"] = Concept.builtins["Int128"]
 
+_np_datetime = np.dtype('datetime64[ns]')
 python_types_to_concepts : dict[Any, Concept] = {
     int: Concept.builtins["Int128"],
     float: Concept.builtins["Float"],
@@ -1213,6 +1216,7 @@ python_types_to_concepts : dict[Any, Concept] = {
     np.dtype('float32'): Concept.builtins["Float"],
     np.dtype('bool'): Concept.builtins["Bool"],
     np.dtype('object'): Concept.builtins["String"],  # Often strings are stored as object dtype
+    _np_datetime: Concept.builtins["DateTime"],
 
     # Pandas extension dtypes
     pd.Int64Dtype(): Concept.builtins["Int128"],
@@ -1655,7 +1659,9 @@ class Expression(Producer):
             raise ValueError(f"Argument index should be positive, got {idx}")
         if len(self._params) <= idx:
             raise ValueError(f"Expression '{self.__str__()}' has only {len(self._params)} arguments")
-        return ArgumentRef(self, self._params[idx])
+        param = self._params[idx]
+        # if param is an Expression then refer the last param of this expression
+        return ArgumentRef(self, param._params[-1] if isinstance(param, Expression) else param)
 
     def __getattr__(self, name: str):
         last = self._params[-1]
@@ -2090,8 +2096,20 @@ class DataColumn(Producer):
         self._data = data
         self._type = _type
         self._name = name if isinstance(name, str) else f"v{name}"
+        if pd.api.types.is_datetime64_any_dtype(_type):
+            _type = _np_datetime
+        # dates are objects in pandas
+        elif pd.api.types.is_object_dtype(_type) and self._is_date_column():
+            _type = date
         self._ref = python_types_to_concepts[_type].ref(self._name)
 
+    def _is_date_column(self) -> bool:
+        sample = self._data._data[self._name].dropna()
+        if sample.empty:
+            return False
+        sample_value = sample.iloc[0]
+        return isinstance(sample_value, date) and not isinstance(sample_value, datetime)
+
     def __str__(self):
         return f"DataColumn({self._name}, {self._type})"
 

relationalai/semantics/lqp/executor.py

@@ -12,6 +12,7 @@ from relationalai import debugging
 from relationalai.semantics.lqp import result_helpers
 from relationalai.semantics.metamodel import ir, factory as f, executor as e
 from relationalai.semantics.lqp.compiler import Compiler
+from relationalai.semantics.lqp.intrinsics import mk_intrinsic_datetime_now
 from relationalai.semantics.lqp.types import lqp_type_to_sql
 from lqp import print as lqp_print, ir as lqp_ir
 from lqp.parser import construct_configure
@@ -258,11 +259,47 @@ class LQPExecutor(e.Executor):
 
         return ", ".join(fields)
 
+    def _construct_configure(self):
+        config_dict = {}
+        # Only set the IVM flag if there is a value in `config`. Otherwise, let
+        # `construct_configure` set the default value.
+        ivm_flag = self.config.get('reasoner.rule.incremental_maintenance', None)
+        if ivm_flag:
+            config_dict['ivm.maintenance_level'] = lqp_ir.Value(value=ivm_flag, meta=None)
+        return construct_configure(config_dict, None)
+    
+    def _compile_intrinsics(self) -> lqp_ir.Epoch:
+        """Construct an epoch that defines a number of built-in definitions used by the
+        emitter."""
+        with debugging.span("compile_intrinsics") as span:
+            debug_info = lqp_ir.DebugInfo(id_to_orig_name={}, meta=None)
+            intrinsics_fragment = lqp_ir.Fragment(
+                id = lqp_ir.FragmentId(id=b"__pyrel_lqp_intrinsics", meta=None),
+                declarations = [
+                    mk_intrinsic_datetime_now(),
+                ],
+                debug_info = debug_info,
+                meta = None,
+            )
+
+            span["compile_type"] = "intrinsics"
+            span["lqp"] = lqp_print.to_string(intrinsics_fragment, {"print_names": True, "print_debug": False, "print_csv_filename": False})
+
+            return lqp_ir.Epoch(
+                writes=[
+                    lqp_ir.Write(write_type=lqp_ir.Define(fragment=intrinsics_fragment, meta=None), meta=None)
+                ],
+                meta=None,
+            )
+
     def compile_lqp(self, model: ir.Model, task: ir.Task):
+        configure = self._construct_configure()
+
         model_txn = None
         if self._last_model != model:
             with debugging.span("compile", metamodel=model) as install_span:
                 _, model_txn = self.compiler.compile(model, {"fragment_id": b"model"})
+                model_txn = txn_with_configure(model_txn, configure)
                 install_span["compile_type"] = "model"
                 install_span["lqp"] = lqp_print.to_string(model_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
                 self._last_model = model
@@ -275,23 +312,26 @@ class LQPExecutor(e.Executor):
             }
             result, final_model = self.compiler.compile_inner(query, options)
             export_info, query_txn = result
+            query_txn = txn_with_configure(query_txn, configure)
             compile_span["compile_type"] = "query"
             compile_span["lqp"] = lqp_print.to_string(query_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
 
-        txn = query_txn
+        # Merge the epochs into a single transactions. Long term the query bits should all
+        # go into a WhatIf action and the intrinsics could be fused with either of them. But
+        # for now we just use separate epochs.
+        epochs = []
+
+        epochs.append(self._compile_intrinsics())
+
         if model_txn is not None:
-            # Merge the two LQP transactions into one. Long term the query bits should all
-            # go into a WhatIf action. But for now we just use two separate epochs.
-            model_epoch = model_txn.epochs[0]
-            query_epoch = query_txn.epochs[0]
-            txn = lqp_ir.Transaction(
-                epochs=[model_epoch, query_epoch],
-                configure=construct_configure({}, None),
-                meta=None,
-            )
+            epochs.append(model_txn.epochs[0])
 
-            # Revalidate now that we've joined two epochs
-            validate_lqp(txn)
+        epochs.append(query_txn.epochs[0])
+
+        txn = lqp_ir.Transaction(epochs=epochs, configure=configure, meta=None)
+
+        # Revalidate now that we've joined all the epochs.
+        validate_lqp(txn)
 
         txn_proto = convert_transaction(txn)
         # TODO (azreika): Should export_info be encoded as part of the txn_proto? [RAI-40312]
@@ -352,3 +392,12 @@ class LQPExecutor(e.Executor):
             # If processing the results failed, revert to the previous model.
             self._last_model = previous_model
             raise e
+
+def txn_with_configure(txn: lqp_ir.Transaction, configure: lqp_ir.Configure) -> lqp_ir.Transaction:
+    """ Return a new transaction with the given configure. If the transaction already has
+    a configure, it is replaced. """
+    return lqp_ir.Transaction(
+        epochs=txn.epochs,
+        configure=configure,
+        meta=txn.meta,
+    )

relationalai/semantics/lqp/intrinsics.py

@@ -0,0 +1,23 @@
+from datetime import datetime, timezone
+
+from relationalai.semantics.lqp import ir as lqp
+from relationalai.semantics.lqp.constructors import mk_abstraction, mk_value, mk_var, mk_type, mk_primitive
+from relationalai.semantics.lqp.utils import lqp_hash
+
+def mk_intrinsic_datetime_now() -> lqp.Def:
+    """Constructs a definition of the current datetime."""
+    id = lqp_hash("__pyrel_lqp_intrinsic_datetime_now")
+    out = mk_var("out")
+    out_type = mk_type(lqp.TypeName.DATETIME)
+    now = mk_value(lqp.DateTimeValue(value=datetime.now(timezone.utc), meta=None))
+    datetime_now = mk_abstraction(
+        [(out, out_type)],
+        mk_primitive("rel_primitive_eq", [out, now]),
+    )
+
+    return lqp.Def(
+        name = lqp.RelationId(id=id, meta=None),
+        body = datetime_now,
+        attrs = [],
+        meta = None,
+    )

relationalai/semantics/lqp/model2lqp.py

@@ -192,12 +192,21 @@ def _translate_effect(ctx: TranslationCtx, effect: Union[ir.Output, ir.Update],
     elif isinstance(effect, ir.Output):
         ctx.output_ids.append((rel_id, def_name))
 
+    # First we collect annotations on the effect itself, e.g. from something like
+    # `select(...).annotate(...)`.
+    annotations = effect.annotations
+    if isinstance(effect, ir.Update):
+        # Then we translate annotations on the relation itself, e.g.
+        # ```
+        # Bar.foo = model.Relationship(...)
+        # Bar.foo.annotate(...)
+        # ```
+        annotations = annotations | effect.relation.annotations
+
     return lqp.Def(
         name = rel_id,
         body = mk_abstraction(projection, new_body),
-        # TODO this only covers the annotations on the effect itself. Annotations on the
-        # relation are not included yet.
-        attrs = _translate_annotations(effect.annotations),
+        attrs = _translate_annotations(annotations),
         meta = None,
     )
 
@@ -697,4 +706,4 @@ def _translate_join(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
 
     output_term = _translate_term(ctx, target)[0]
 
-    return lqp.Reduce(meta=None, op=op, body=body, terms=[output_term])
+    return lqp.Reduce(meta=None, op=op, body=body, terms=[output_term])

relationalai/semantics/lqp/passes.py

@@ -8,7 +8,7 @@ from relationalai.semantics.metamodel.util import FrozenOrderedSet
 
 from relationalai.semantics.metamodel.rewrite import Flatten
 # TODO: Move this into metamodel.rewrite
-from relationalai.semantics.rel.rewrite import QuantifyVars, CDC
+from relationalai.semantics.rel.rewrite import QuantifyVars, CDC, ExtractCommon
 
 from relationalai.semantics.lqp.utils import output_names
 
@@ -25,8 +25,7 @@ def lqp_passes() -> list[Pass]:
         InferTypes(),
         DNFUnionSplitter(),
         ExtractKeys(),
-        # Broken
-        # ExtractCommon(),
+        ExtractCommon(),
         Flatten(),
         Splinter(), # Splits multi-headed rules into multiple rules
         QuantifyVars(), # Adds missing existentials

relationalai/semantics/lqp/primitives.py

@@ -1,7 +1,7 @@
 from relationalai.semantics.metamodel.types import digits_to_bits
 from relationalai.semantics.lqp import ir as lqp
 from relationalai.semantics.lqp.types import is_numeric
-from relationalai.semantics.lqp.utils import UniqueNames
+from relationalai.semantics.lqp.utils import UniqueNames, lqp_hash
 from relationalai.semantics.lqp.constructors import mk_primitive, mk_specialized_value, mk_type, mk_value, mk_var
 
 rel_to_lqp = {
@@ -62,6 +62,7 @@ rel_to_lqp = {
     "date_add": "rel_primitive_typed_add_date_period",
     "date_subtract": "rel_primitive_typed_subtract_date_period",
     "dates_period_days": "rel_primitive_date_days_between",
+    "datetime_now": "__pyrel_lqp_intrinsic_datetime_now",
     "datetime_add": "rel_primitive_typed_add_datetime_period",
     "datetime_subtract": "rel_primitive_typed_subtract_datetime_period",
     "datetime_year": "rel_primitive_datetime_year",
@@ -175,6 +176,16 @@ def build_primitive(
     terms, term_types = _reorder_primitive_terms(lqp_name, terms, term_types)
     _assert_primitive_terms(lqp_name, terms, term_types)
 
+    # Handle intrinsics. To callers of `build_primitive` the distinction between intrinsic
+    # and primitive doesn't matter, so we don't want to burden them with that detail.
+    # Intrinsics are built-in definitions added by the LQP emitter, that user logic can just
+    # refer to.
+    if lqp_name == "__pyrel_lqp_intrinsic_datetime_now":
+        id = lqp.RelationId(id=lqp_hash(lqp_name), meta=None)
+        assert len(terms) == 1
+        assert isinstance(terms[0], lqp.Term)
+        return lqp.Atom(name=id, terms=[terms[0]], meta=None)
+
     return mk_primitive(lqp_name, terms)
 
 def relname_to_lqp_name(name: str) -> str:

relationalai/semantics/metamodel/builtins.py

@@ -391,7 +391,7 @@ erfinv = f.relation(
 
 # Strings
 concat = f.relation("concat", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.String)])
-num_chars = f.relation("num_chars", [f.input_field("a", types.String), f.field("b", types.Int128)])
+num_chars = f.relation("num_chars", [f.input_field("a", types.String), f.field("b", types.Int64)])
 starts_with = f.relation("starts_with", [f.input_field("a", types.String), f.input_field("b", types.String)])
 ends_with = f.relation("ends_with", [f.input_field("a", types.String), f.input_field("b", types.String)])
 contains = f.relation("contains", [f.input_field("a", types.String), f.input_field("b", types.String)])
@@ -406,7 +406,13 @@ replace = f.relation("replace", [f.input_field("a", types.String), f.input_field
 split = f.relation("split", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Int64), f.field("d", types.String)])
 # should be a separate builtin. SQL emitter compiles it differently
 split_part = f.relation("split_part", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Int64), f.field("d", types.String)])
+
+# regex
 regex_match = f.relation("regex_match", [f.input_field("a", types.String), f.input_field("b", types.String)])
+regex_match_all = f.relation("regex_match_all", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64),  f.field("d", types.String)])
+capture_group_by_index = f.relation("capture_group_by_index", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64), f.input_field("d", types.Int64), f.field("e", types.String)])
+capture_group_by_name = f.relation("capture_group_by_name", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64), f.input_field("d", types.String), f.field("e", types.String)])
+escape_regex_metachars = f.relation("escape_regex_metachars", [f.input_field("a", types.String), f.field("b", types.String)])
 
 # Dates
 date_format = f.relation("date_format", [f.input_field("a", types.Date), f.input_field("b", types.String), f.field("c", types.String)])
@@ -422,6 +428,7 @@ date_add = f.relation("date_add", [f.input_field("a", types.Date), f.input_field
 dates_period_days = f.relation("dates_period_days", [f.input_field("a", types.Date), f.input_field("b", types.Date), f.field("c", types.Int64)])
 datetimes_period_milliseconds = f.relation("datetimes_period_milliseconds", [f.input_field("a", types.DateTime), f.input_field("b", types.DateTime), f.field("c", types.Int64)])
 date_subtract = f.relation("date_subtract", [f.input_field("a", types.Date), f.input_field("b", types.Int64), f.field("c", types.Date)])
+datetime_now = f.relation("datetime_now", [f.field("a", types.DateTime)])
 datetime_add = f.relation("datetime_add", [f.input_field("a", types.DateTime), f.input_field("b", types.Int64), f.field("c", types.DateTime)])
 datetime_subtract = f.relation("datetime_subtract", [f.input_field("a", types.DateTime), f.input_field("b", types.Int64), f.field("c", types.DateTime)])
 datetime_year = f.relation("datetime_year", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])

relationalai/semantics/metamodel/factory.py

@@ -185,10 +185,11 @@ def lit(value: Any) -> ir.Value:
         return ir.Literal(types.Bool, value)
     elif isinstance(value, decimal.Decimal):
         return ir.Literal(types.Decimal, value)
-    elif isinstance(value, datetime.date):
-        return ir.Literal(types.Date, value)
+    # datetime.datetime is a subclass of datetime.date, so check it first
     elif isinstance(value, datetime.datetime):
         return ir.Literal(types.DateTime, value)
+    elif isinstance(value, datetime.date):
+        return ir.Literal(types.Date, value)
     elif isinstance(value, list):
         return tuple([lit(v) for v in value])
     else:

relationalai/semantics/reasoners/graph/core.py

@@ -3865,12 +3865,19 @@ class Graph():
 
 
     @include_in_docs
-    def triangle_count(self):
+    def triangle_count(self, *, of: Optional[Relationship] = None):
         """Returns a binary relationship containing the number of unique triangles each node belongs to.
 
         A triangle is a set of three nodes where each node has a directed
         or undirected edge to the other two nodes, forming a 3-cycle.
 
+        Parameters
+        ----------
+        of : Relationship, optional
+            A unary relationship containing a subset of the graph's nodes. When
+            provided, constrains the domain of the triangle count computation: only
+            triangle counts of nodes in this relationship are computed and returned.
+
         Returns
         -------
         Relationship
@@ -3926,6 +3933,31 @@ class Graph():
         3   4      0
         4   5      0
 
+        >>> # 4. Use 'of' parameter to constrain the set of nodes to compute triangle counts of
+        >>> # Define a subset containing only nodes 1 and 3
+        >>> subset = model.Relationship(f"{{node:{Node}}} is in subset")
+        >>> node = Node.ref()
+        >>> where(union(node.id == 1, node.id == 3)).define(subset(node))
+        >>>
+        >>> # Get triangle counts only of nodes in the subset
+        >>> constrained_triangle_count = graph.triangle_count(of=subset)
+        >>> select(node.id, count).where(constrained_triangle_count(node, count)).inspect()
+        ▰▰▰▰ Setup complete
+           id  count
+        0   1      1
+        1   3      1
+
+        Notes
+        -----
+        The ``triangle_count()`` method, called with no parameters, computes and caches
+        the full triangle count relationship, providing efficient reuse across multiple
+        calls to ``triangle_count()``. In contrast, ``triangle_count(of=subset)`` computes a
+        constrained relationship specific to the passed-in ``subset`` and that
+        call site. When a significant fraction of the triangle count relation is needed
+        across a program, ``triangle_count()`` is typically more efficient; this is the
+        typical case. Use ``triangle_count(of=subset)`` only when small subsets of the
+        triangle count relationship are needed collectively across the program.
+
         See Also
         --------
         triangle
@@ -3933,15 +3965,35 @@ class Graph():
         num_triangles
 
         """
+        if of is not None:
+            self._validate_node_subset_parameter(of)
+            return self._triangle_count_of(of)
         return self._triangle_count
 
     @cached_property
     def _triangle_count(self):
         """Lazily define and cache the self._triangle_count relationship."""
+        return self._create_triangle_count_relationship(nodes_subset=None)
+
+    def _triangle_count_of(self, nodes_subset: Relationship):
+        """
+        Create a triangle count relationship constrained to the subset of nodes
+        in `nodes_subset`. Note this relationship is not cached; it is
+        specific to the callsite.
+        """
+        return self._create_triangle_count_relationship(nodes_subset=nodes_subset)
+
+    def _create_triangle_count_relationship(self, *, nodes_subset: Optional[Relationship]):
+        """Create a triangle count relationship, optionally constrained to a subset of nodes."""
         _triangle_count_rel = self._model.Relationship(f"{{node:{self._NodeConceptStr}}} belongs to {{count:Integer}} triangles")
 
+        if nodes_subset is None:
+            node_constraint = self.Node # No constraint on nodes.
+        else:
+            node_constraint = nodes_subset(self.Node)  # Nodes constrained to given subset.
+
         where(
-            self.Node,
+            node_constraint,
             _count := self._nonzero_triangle_count_fragment(self.Node) | 0
         ).define(_triangle_count_rel(self.Node, _count))
 

relationalai/semantics/reasoners/optimization/solvers_dev.py

@@ -2,12 +2,15 @@ from __future__ import annotations
 from typing import Union
 import textwrap
 import uuid
+import time
 
 from relationalai.semantics.snowflake import Table
 from relationalai.semantics import std
 from relationalai.semantics.internal import internal as b # TODO(coey) change b name or remove b.?
 from relationalai.semantics.rel.executor import RelExecutor
 from relationalai.semantics.lqp.executor import LQPExecutor
+from relationalai.tools.constants import DEFAULT_QUERY_TIMEOUT_MINS
+from relationalai.util.timeout import calc_remaining_timeout_minutes
 
 from .common import make_name
 from relationalai.experimental.solvers import Solver
@@ -243,6 +246,17 @@ class SolverModelDev:
         app_name = resources.get_app_name()
         print(app_name)
 
+        # Note: currently the query timeout is not propagated to the steps 'export model
+        # relations', and 'import result relations'. For those steps the default query
+        # timeout value defined in the config will apply.
+        # TODO: propagate the query timeout to those steps as well.
+        query_timeout_mins = kwargs.get("query_timeout_mins", None)
+        config = self._model._config
+        if query_timeout_mins is None and (timeout_value := config.get("query_timeout_mins", DEFAULT_QUERY_TIMEOUT_MINS)) is not None:
+            query_timeout_mins = int(timeout_value)
+        config_file_path = getattr(config, 'file_path', None)
+        start_time = time.monotonic()
+
         # 1. export model relations
         print("export model relations")
         # TODO(coey) perf: only export the relations that are actually used in the model
@@ -266,6 +280,9 @@ class SolverModelDev:
             b.select(*rel._field_refs).where(rel(*rel._field_refs)).into(table)
 
         # 2. execute solver job and wait for completion
+        remaining_timeout_minutes = calc_remaining_timeout_minutes(
+            start_time, query_timeout_mins, config_file_path=config_file_path,
+        )
         print("execute solver job")
         payload = {
             "solver": solver.solver_name.lower(),
@@ -273,7 +290,9 @@ class SolverModelDev:
             "input_id": input_id,
             "data_type": self._data_type
         }
-        job_id = solver._exec_job(payload, log_to_console=log_to_console)
+        job_id = solver._exec_job(
+            payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes,
+        )
         print(f"job id: {job_id}") # TODO(coey) maybe job_id is not useful
 
         # 3. import result relations

relationalai/semantics/reasoners/optimization/solvers_pb.py

@@ -2,12 +2,15 @@ from __future__ import annotations
 from typing import Any, Union
 import textwrap
 import uuid
+import time
 
 from relationalai.semantics.metamodel.util import ordered_set
 from relationalai.semantics.internal import internal as b # TODO(coey) change b name or remove b.?
 from relationalai.semantics.rel.executor import RelExecutor
 from .common import make_name
 from relationalai.experimental.solvers import Solver
+from relationalai.tools.constants import DEFAULT_QUERY_TIMEOUT_MINS
+from relationalai.util.timeout import calc_remaining_timeout_minutes
 
 _Any = Union[b.Producer, str, float, int]
 _Number = Union[b.Producer, float, int]
@@ -222,6 +225,14 @@ class SolverModelPB:
         assert isinstance(executor, RelExecutor)
         prefix_l = f"solvermodel_{self._id}_"
 
+        query_timeout_mins = kwargs.get("query_timeout_mins", None)
+        config = self._model._config
+        if query_timeout_mins is None and (timeout_value := config.get("query_timeout_mins", DEFAULT_QUERY_TIMEOUT_MINS)) is not None:
+            query_timeout_mins = int(timeout_value)
+        config_file_path = getattr(config, 'file_path', None)
+        start_time = time.monotonic()
+        remaining_timeout_minutes = query_timeout_mins
+
         # 1. Materialize the model and store it.
         print("export model")
         b.select(b.count(self.Variable)).to_df() # TODO(coey) weird hack to avoid uninitialized properties error
@@ -244,14 +255,22 @@ class SolverModelPB:
         def config[:envelope, :payload, :data]: model_string
         def config[:envelope, :payload, :path]: "{model_uri}"
         def export {{ config }}
-        """))
+        """), query_timeout_mins=remaining_timeout_minutes)
 
         # 2. Execute job and wait for completion.
         print("execute solver job")
-        job_id = solver._exec_job(payload, log_to_console=log_to_console)
+        remaining_timeout_minutes = calc_remaining_timeout_minutes(
+            start_time, query_timeout_mins, config_file_path=config_file_path,
+        )
+        job_id = solver._exec_job(
+            payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes,
+        )
 
         # 3. Extract result.
         print("extract result")
+        remaining_timeout_minutes = calc_remaining_timeout_minutes(
+            start_time, query_timeout_mins, config_file_path=config_file_path,
+        )
         extract_str = textwrap.dedent(f"""
         def raw_result {{
             load_binary["snowflake://APP_STATE.RAI_INTERNAL_STAGE/job-results/{job_id}/result.binpb"]
@@ -289,7 +308,9 @@ class SolverModelPB:
                     ::std::mirror::convert(std::mirror::typeof[Int128], j, i)
                 )
             """)
-        executor.execute_raw(extract_str, readonly=False)
+        executor.execute_raw(
+            extract_str, readonly=False, query_timeout_mins=remaining_timeout_minutes,
+        )
 
         print("finished solve")
         return None

relationalai/semantics/rel/compiler.py

@@ -12,7 +12,7 @@ from relationalai.semantics.metamodel.visitor import ReadWriteVisitor
 from relationalai.semantics.metamodel.util import OrderedSet, group_by, NameCache, ordered_set
 
 from relationalai.semantics.rel import rel, rel_utils as u, builtins as rel_bt
-from relationalai.semantics.rel.rewrite import CDC, QuantifyVars
+from relationalai.semantics.rel.rewrite import CDC, QuantifyVars, ExtractCommon
 
 import math
 
@@ -32,7 +32,7 @@ class Compiler(c.Compiler):
             InferTypes(),
             DNFUnionSplitter(),
             ExtractKeys(),
-            # rewrite.ExtractCommon(),
+            ExtractCommon(),
             Flatten(),
             Splinter(),
             QuantifyVars(),
@@ -125,21 +125,6 @@ class ModelToRel:
                 tuple([rel.Annotation("inline", ())]),
             ))
 
-        if "pyrel_num_chars" in reads:
-            defs.append(
-                rel.Def("pyrel_num_chars",
-                    tuple([rel.Var("x"), rel.Var("y")]),
-                    rel.Exists(
-                        tuple([rel.Var("z")]),
-                        rel.And(ordered_set(
-                            rel.atom("::std::common::num_chars", tuple([rel.Var("x"), rel.Var("z")])),
-                            rel.Atom(self._convert_abs(types.Int64, types.Int128), tuple([rel.Var("z"), rel.Var("y")])),
-                        )),
-                    ),
-                    tuple([rel.Annotation("inline", ())]),
-                ),
-            )
-
         if "pyrel_count" in reads:
             defs.append(
                 rel.Def("pyrel_count",
@@ -249,6 +234,9 @@ class ModelToRel:
                     ),
             )
 
+        if "pyrel_regex_search" in reads:
+            raise NotImplementedError("pyrel_regex_search is not implemented")
+
         return defs
 
     @staticmethod

relationalai/semantics/rel/executor.py

@@ -305,8 +305,8 @@ 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) -> DataFrame:
-        raw_results = self.resources.exec_raw(self.database, self.engine, raw_rel, readonly, nowait_durable=True)
+    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)
         df, errs = result_helpers.format_results(raw_results, None, generation=Generation.QB)  # Pass None for task parameter
         self.report_errors(errs)
         return df

relationalai/semantics/rel/rel.py

@@ -223,6 +223,12 @@ class Printer(BasePrinter):
             self._print("::std::common::int[128,")
             self._print(str(value))
             self._print("]")
+        elif isinstance(value, datetime):
+            if value.tzinfo is None:
+                value = value.replace(tzinfo=timezone.utc)
+            self._print(value.astimezone(timezone.utc).isoformat())
+        elif isinstance(value, date):
+            self._print(value.isoformat())
         else:
             self._print(str(value))