relationalai 1.0.0a1__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

relationalai/semantics/std/aggregates.py

@@ -10,7 +10,6 @@ AggValue = Value | Distinct
 # Aggregates
 #------------------------------------------------------
 
-# TODO - overloads
 _sum = library.Relation("sum", fields=[Field.input("value", Numeric), Field("result", Numeric)],
                         overloads=[[Number, Number], [Float, Float]])
 _count = library.Relation("count", fields=[Field("result", Integer)])

relationalai/semantics/std/datetime.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 from relationalai.semantics.std import floats
 
 from . import StringValue, IntegerValue, DateValue, DateTimeValue, math, common
-from ..frontend.base import Aggregate, Library, Concept, NumberConcept, Expression, Field, Literal, Variable
+from ..frontend.base import Aggregate, Library, Concept, MetaRef, NumberConcept, Expression, Field, Literal, Variable
 from ..frontend.core import Float, Number, String, Integer, Date, DateTime
+from ..frontend import core
 from .. import select
 
 from typing import Union, Literal
@@ -162,6 +163,7 @@ class date:
             num_days = cls.period_days(start, end)
             if freq in ["W", "M", "Y"]:
                 range_end = math.ceil(num_days * _days[freq])
+                range_end = core.cast(MetaRef(Integer), range_end)
             else:
                 range_end = num_days
             # date_range is inclusive. add 1 since std.range is exclusive
@@ -348,6 +350,7 @@ class datetime:
                 _end = num_ms
             else:
                 _end = math.ceil(num_ms * Float(_milliseconds[freq]))
+            _end = core.cast(MetaRef(Integer), _end)
             # datetime_range is inclusive. add 1 since common.range is exclusive
             ix = common.range(0, _end + 1, 1)
         else:

relationalai/shims/executor.py

@@ -29,10 +29,28 @@ TYPER_DEBUGGER=False
 # PRINT_RESULT=True
 # TYPER_DEBUGGER=True
 
+@lru_cache()
+def get_config():
+    return Config()
+
+def with_source(item: mm.Node):
+    if not hasattr(item, "source"):
+        raise ValueError(f"Item {item} has no source")
+    elif item.source is None:
+        return {}
+    elif debugging.DEBUG:
+        source = item.source.block
+        if source:
+            return { "file": source.file, "line": source.line, "source": source.source }
+        else:
+            return {"file":item.source.file, "line":item.source.line}
+    else:
+        return {"file":item.source.file, "line":item.source.line}
+
 def execute(query: Fragment, model: Model|None = None, executor=None, export_to="", update=False):
     if not executor:
         # use_lqp = Config().reasoner.rule.use_lqp
-        use_lqp = bool(Config().get("reasoner.rule.use_lqp", True))
+        use_lqp = bool(get_config().get("reasoner.rule.use_lqp", True))
         executor = "lqp" if use_lqp else "rel"
     mm_model = model.to_metamodel() if model else None
     mm_query = query.to_metamodel()
@@ -41,7 +59,7 @@ def execute(query: Fragment, model: Model|None = None, executor=None, export_to=
 
 def execute_mm(mm_query: mm.Task, mm_model: mm.Model|None = None, executor="lqp", export_to="", update=False, model: Model|None = None):
     # perform type inference
-    typer = Typer()
+    typer = Typer(enforce=False)
     # normalize the metamodel
     normalizer = Normalize()
     # translate the metamodel into a v0 query
@@ -117,7 +135,7 @@ def execute_mm(mm_query: mm.Task, mm_model: mm.Model|None = None, executor="lqp"
                     f.write(msg)
                     f.write('\n')
 
-    if DRY_RUN:
+    if DRY_RUN or get_config().get("compiler.dry_run", False):
         results = []
     else:
         # create snowflake tables for all the tables that have been used
@@ -132,7 +150,7 @@ def execute_mm(mm_query: mm.Task, mm_model: mm.Model|None = None, executor="lqp"
 
         # get an executor and execute
         executor = _get_executor(executor, model.name if model else "")
-        with debugging.span("query", tag=None, export_to=export_to) as query_span:
+        with debugging.span("query", tag=None, export_to=export_to, dsl="", **with_source(mm_query)) as query_span:
             if isinstance(executor, (LQPExecutor, RelExecutor)):
                 results = executor.execute(v0_model, v0_query, export_to=export_table, update=update)
             else:

relationalai/shims/mm2v0.py

@@ -21,6 +21,8 @@ from ..semantics.backends.lqp import annotations as lqp_annotations
 from v0.relationalai.semantics.metamodel import ir as v0, builtins as v0_builtins, types as v0_types, factory as f
 from v0.relationalai.semantics.metamodel.util import FrozenOrderedSet, frozen, ordered_set, filter_by_type, OrderedSet
 from v0.relationalai.semantics.internal.internal import literal_value_to_type
+from v0.relationalai.semantics.metamodel.typer import typer as v0_typer
+from v0.relationalai.clients.util import IdentityParser
 
 from .hoister import Hoister
 from .helpers import is_output_update, is_main_output
@@ -131,6 +133,16 @@ class Translator():
     def translate_frozen(self, nodes: seq[mm.Node], parent, ctx) -> FrozenOrderedSet[v0.Node]:
         return frozen(*self.translate_seq(nodes, parent, ctx))
 
+    #------------------------------------------------------
+    # Helper
+    #------------------------------------------------------
+
+    # NOTE: This has to match what is done in the v0 snowflake.Table class as that is what CDC
+    # produces. If there's a quote in the table name, then we take it verbatim, otherwise we lowercase it.
+    def translate_table_name(self, table: mm.Table) -> str:
+        name = IdentityParser(table.name).identifier
+        name = name.lower() if '"' not in table.name else table.name.replace('"', '_')
+        return sanitize(name)
 
     #-----------------------------------------------------------------------------
     # Capabilities, Reasoners
@@ -279,12 +291,22 @@ class Translator():
                         else:
                             overloads.update(x) # type: ignore
             overloads.update(self.translate_frozen(r.overloads, r, ctx))  # type: ignore
+            annotations = self.translate_seq(r.annotations, r, ctx)  # type: ignore
+            name = r.name
+            fields = self.translate_seq(r.fields, r, ctx)  # type: ignore
+            # We need to turn column relations into what the CDC pass would otherwise produce
+            # by making the relation name be the table name and adding a symbol field at the front
+            # representing the column name
+            if r.fields and isinstance(r.fields[0].type, mm.Table) and r in r.fields[0].type.columns:
+                name = self.translate_table_name(r.fields[0].type)
+                fields = (v0.Field("symbol", v0_types.Symbol, False), *fields) # type: ignore
+                annotations = annotations + (v0_builtins.external_annotation,)
 
             return v0.Relation(
-                name=r.name,
-                fields=self.translate_frozen(r.fields, r, ctx), # type: ignore
+                name=name,
+                fields=frozen(*fields), # type: ignore
                 requires=self.translate_frozen(r.requires, r, ctx), # type: ignore
-                annotations=self.translate_frozen(r.annotations, r, ctx), # type: ignore
+                annotations=frozen(*annotations), # type: ignore
                 overloads=overloads.frozen(), # type: ignore
             )
 
@@ -321,6 +343,7 @@ class Translator():
         b.core.Date: v0_types.Date,
         b.core.DateTime: v0_types.DateTime,
         b.core.Float: v0_types.Float,
+        b.core.Hash: v0_types.Hash,
     }
 
     def translate_scalartype(self, t: mm.ScalarType, parent: mm.Node, ctx) -> v0.ScalarType|v0.Relation|None:
@@ -334,18 +357,14 @@ class Translator():
             assert isinstance(actual_type, v0.ScalarType)
             fields = [v0.Field(name="entity", type=actual_type, input=False)] # type: ignore
             annotations = [v0_builtins.concept_relation_annotation]
+            name = t.name
             if isinstance(t, mm.Table):
                 annotations.append(v0_builtins.external_annotation)
-                annotations.append(v0_builtins.from_cdc_annotation)
-                for col in t.columns:
-                    fields.append(v0.Field(
-                        name=col.name,
-                        type=self.translate_node(col.fields[-1].type, col, Context.MODEL), # type: ignore
-                        input=False
-                    ))
+                name = self.translate_table_name(t)
+                fields.insert(0, v0.Field(name="symbol", type=v0_types.Symbol, input=False)) # type: ignore
 
             type_relation = v0.Relation(
-                name=t.name,
+                name=name,
                 fields=tuple(fields), # type: ignore
                 requires=frozen(),
                 annotations=frozen(*annotations), # type: ignore
@@ -541,7 +560,7 @@ class Translator():
         # inline logicals if possible
         new_children = []
         for c in children:
-            if isinstance(c, v0.Logical) and not c.hoisted and len(c.body) == 1:
+            if isinstance(c, v0.Logical) and not c.hoisted and len(c.body) == 1 and not isinstance(c.body[0], (v0.Aggregate, v0.Rank)):
                 new_children.extend(c.body)
             else:
                 new_children.append(c)
@@ -590,10 +609,49 @@ class Translator():
                 return outputs
 
             # if this is an optional logical but we're not hoisting anything and not updating,
-            # then it's effectively a no-op since it cannot affect the query. Just return the outputs.
+            # then it's possible we're filtering an outer variable, but only for this column. If
+            # so, we need to alias the output and hoist it.
             # this is important because the LQP stack blows up if there's a logical with no effect
             if l.optional and not hoisted and not any(isinstance(c, v0.Update) for c in children):
-                return outputs
+                # if there are no lookups, then this really is a no-op, just return outputs
+                # LQP blows up with e.g. a match-only logical
+                if not any(isinstance(c, v0.Lookup) for c in children):
+                    return outputs
+                # otherwise, make sure we filter the outer variable through aliasing
+                new_children = [*children]
+                new_hoists = []
+                new_outputs = []
+                # add an eq to a new var for the output, hoist the new var, change the output to use the new var
+                for output in outputs:
+                    # shim outputs always only have one alias
+                    (name, orig_var) = output.aliases.data[0]
+                    # if the original var is not a Var or Literal, or it's already in the keys, skip (we can't filter keys)
+                    if not isinstance(orig_var, (v0.Var, v0.Literal)) or (output.keys and orig_var in output.keys): #type: ignore
+                        new_outputs.append(output)
+                        continue
+                    new_var = v0.Var(
+                        type=orig_var.type,
+                        name=f"{orig_var.name if isinstance(orig_var, v0.Var) else 'literal'}_hoisted"
+                    )
+                    new_output = v0.Output(
+                        engine=None,
+                        aliases=frozen((name, new_var)),
+                        keys=output.keys,
+                        annotations=output.annotations
+                    )
+                    eq = v0.Lookup(
+                        engine=None,
+                        relation=v0_builtins.eq,
+                        args=(new_var, orig_var),
+                        annotations=frozen()
+                    )
+                    new_children.append(eq)
+                    new_hoists.append(v0.Default(new_var, None))
+                    new_outputs.append(new_output)
+                outputs = new_outputs
+                hoisted = tuple(new_hoists)
+                children = tuple(new_children)
+                # return outputs
 
             # return outputs + a logical with the other children
             outputs.append(
@@ -782,40 +840,26 @@ class Translator():
                     args=(var, col_var), # type: ignore
                     annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
                 )
-            else:
+            # if this is a data column, we just ignore it as the data node already binds the variables
+            elif isinstance(l.args[0].type, mm.Data):
                 return None
+            # Otherwise we keep the lookup because that's what the LQP stack expect (the lookup gets repeated for
+            # each column)
+
 
         relation, args = self._resolve_reading(l, ctx)
         if relation is None:
             return None
 
         # External Table Column lookups
-        # we have to take the 6nf column relations and pull them into a single wide lookup
-        # making sure that the variable get mapped correctly. To match the expectations of
-        # v0, we also have to make sure that if we're looking up the table row itself, that
-        # it is wrapped in its own logical
+        # we have to prepend the column symbol to the args
         root_type = l.relation.fields[0].type
         if isinstance(root_type, mm.Table):
             self.used_tables.add(root_type)
-            assert isinstance(l.args[0], mm.Var)
-            is_col = l.relation in root_type.columns
             is_table = l.relation == root_type
-            if is_col:
-                self.column_map[l.args[0]][l.relation] = args[-1]
-                # we always lookup the full table, so replace the relation and args
-                relation = self.translate_node(root_type, l, ctx)
-
-            # this is a lookup on the table itself or the columns, translate to the column vars
-            if is_col or is_table:
-                mapped = self.column_map.get(l.args[0], {})
-                col_args = []
-                for col in root_type.columns:
-                    v = mapped.setdefault(col, v0.Var(
-                        type=self.translate_node(col.fields[-1].type, col, Context.MODEL), # type: ignore
-                        name=f"{col.name}"
-                    ))
-                    col_args.append(v)
-                args = tuple([args[0], *col_args]) # type: ignore
+            if is_table or l.relation in root_type.columns:
+                sym = "METADATA$KEY" if is_table else l.relation.name
+                args = (v0.Literal(type=v0_types.Symbol, value=sym), *args)
 
         # Specific rewrites
         rewrite = self.rewrite_lookup(l, parent, ctx)
@@ -1109,6 +1153,18 @@ class Translator():
     def decrement(self, l: mm.Lookup, index: int, ctx):
         """ Rewrite the lookup such that the arg at `index` is decremented by 1 before the
         lookup.  """
+        x = l.args[index]
+        if isinstance(x, mm.Literal):
+            # if the arg is a literal, just decrement the literal directly
+            new_literal = mm.Literal(type=x.type, value=x.value - 1) # type: ignore
+            return v0.Lookup(
+                    engine=None,
+                    relation=self.translate_node(l.relation), # type: ignore
+                    args=tuple(self.translate_value(arg, l, ctx) if i != index else self.translate_value(new_literal, l, ctx) for i, arg in enumerate(l.args)),
+                    annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+            )
+
+        # arg is not a literal, so we need to create a tmp var to store the decremented value
         tmp = self.translate_value(mm.Var(type=b.core.Number, name="tmp"), l, ctx)
         # lookup(..., tmp, ...)
         new = v0.Lookup(
@@ -1137,7 +1193,21 @@ class Translator():
         inputs = []
         outputs = []
         args = []
-        for arg, field in zip(l.args, l.relation.fields):
+        fields = l.relation.fields
+        # if there are overloads, we need to cast based on the most compatible overload
+        if l.relation.overloads:
+            inf = float("inf")
+            min_cost = inf
+            for overload in l.relation.overloads:
+                total = 0
+                for arg, field in zip(l.args, overload.fields):
+                    if v0_typer.to_type(arg) != field.type:
+                        total += 1
+                if total < min_cost:
+                    min_cost = total
+                    fields = overload.fields
+
+        for arg, field in zip(l.args, fields):
             target_type = field.type
             if target_type is None or not isinstance(arg, (v0.Var, v0.Literal)) or arg.type == target_type:
                 args.append(arg)

{relationalai-1.0.0a1.dist-info → relationalai-1.0.0a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 1.0.0a1
+Version: 1.0.0a2
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
 Requires-Python: >=3.10

{relationalai-1.0.0a1.dist-info → relationalai-1.0.0a2.dist-info}/RECORD

@@ -17,23 +17,23 @@ relationalai/semantics/__init__.py,sha256=N3rTlD4oIyIkCqTNNWWUjQbJMyEbot6XNR_Nvm
 relationalai/semantics/backends/lqp/annotations.py,sha256=TUk_fuXyBWs7H4BHx-4jZGonSD8MdgPswt-D2k7QC-4,390
 relationalai/semantics/backends/sql/sql_compiler.py,sha256=p_1YjROlcmu0kwvI32qUWAmMQntp_A6H3_vgGDDLiQk,10628
 relationalai/semantics/frontend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-relationalai/semantics/frontend/base.py,sha256=9JgD-re_E2GakehRd7fbW3HG_Aq5qxwEy64NguzXCrE,65652
+relationalai/semantics/frontend/base.py,sha256=yUBeXvF0cRYzKk4sTSh7Ja5PUSwEszvyuQjT1E25Cjc,65783
 relationalai/semantics/frontend/core.py,sha256=mwPG9HxQWrh77O5n7j_M9lt96gTyYsoUE_BFz7qcfXw,7396
-relationalai/semantics/frontend/front_compiler.py,sha256=a8LEGudqL4MTHV2QTQC9LJo43g_fxQ7K-HlRDwrfySg,57241
+relationalai/semantics/frontend/front_compiler.py,sha256=q84SDS1AQllKSnZya1k8gUG_SD12zIl9QbWIU9zFliU,57403
 relationalai/semantics/frontend/pprint.py,sha256=IMkKwkZs3ohOIjYUIjT10poa1L39F_PrLdSjV-D4wpk,14977
 relationalai/semantics/metamodel/__init__.py,sha256=mISE8niHeEAD6QjX8pi_apFfMIVCZ7dGeCXFGtFPTvk,364
-relationalai/semantics/metamodel/builtins.py,sha256=85XxoPeQstc9yy5HkB_gsak3zh_kl-WYC5gF5l_rHkw,6950
-relationalai/semantics/metamodel/metamodel.py,sha256=-DfYtsDTaAGGYS7aRmVvpxaZFqP1d8x0okfW_RniFfQ,12778
+relationalai/semantics/metamodel/builtins.py,sha256=rmeVdjw3kDSsx7TjpnFpy8W6OrHuUV1GQwazWhaWrG0,7009
+relationalai/semantics/metamodel/metamodel.py,sha256=TgIufxJslJZkf5_RleTU19i2h0DTW6CodSYqwyVcLEc,13899
 relationalai/semantics/metamodel/metamodel_analyzer.py,sha256=tusDRO2az1yiF951SDg-cHOaNQ1M7qw1HG1cxV3YuxU,16228
 relationalai/semantics/metamodel/metamodel_compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-relationalai/semantics/metamodel/pprint.py,sha256=RqXi5gEArG4bMqQ4q2_MAoCikSKgAXkVivOWqdPpayk,15567
+relationalai/semantics/metamodel/pprint.py,sha256=65t7tZTfBP2qOlKShYM8nwrbsiS3gKaCYkUJepu0a2o,15684
 relationalai/semantics/metamodel/rewriter.py,sha256=CEkYxsyFPF-nEHktJxwzOY6RQzo9Nr4Welhw2YDq9q8,8313
-relationalai/semantics/metamodel/typer.py,sha256=6DIAIigfrRwf3Soi43MMHPDjxG9VuzboIpq2QdorVy0,52707
+relationalai/semantics/metamodel/typer.py,sha256=Q35spCuIRMGE2BslgWiyZvQWb3Z0VzCx1YF_Lzk1Sts,55268
 relationalai/semantics/std/__init__.py,sha256=_cbDmeCT634GtdGJ0CqgfJw6pFaJR0ajR3B_bWCr_9A,2627
-relationalai/semantics/std/aggregates.py,sha256=uuMhRobpib0aZaH_fAyJZ-8YI9_0fuEDFtgLekTOODk,6278
+relationalai/semantics/std/aggregates.py,sha256=uCwoBLmuRBBq9lTf5ACD3yosvtp5Wi8IQUCF_dKWS80,6259
 relationalai/semantics/std/common.py,sha256=raWuvX2u4juKPU0BKtqF5xvJSDjKHF1BWQVFioBmOf8,1658
 relationalai/semantics/std/constraints.py,sha256=ePaVEWdlmO1AkawC-QaOKzXw2j2YUFD_-2bstBN8Rto,1587
-relationalai/semantics/std/datetime.py,sha256=6XMc8ZevrV7rzxdG89_aOpoK8R8Kd6zkvEq4kYkK524,21372
+relationalai/semantics/std/datetime.py,sha256=p2pKTWqARsc5SytfPdnXp9J6Ot4IsSCfGIvfIUJe5NM,21529
 relationalai/semantics/std/decimals.py,sha256=tkYGiOyLuzJPTXb8bHHlx7bA0e_FnVFGyFkzaFzGsdc,1863
 relationalai/semantics/std/floats.py,sha256=UpHkgMeUdvqu_pRAlay_KOqWb0e-uz3SK51sH4kNAWQ,490
 relationalai/semantics/std/integers.py,sha256=YxNk-pLtbYtuBVr2BTzdAmhiNxkZJW3wwHDYLk63wfo,1053
@@ -42,10 +42,10 @@ relationalai/semantics/std/numbers.py,sha256=AcmESbBXIQDkDL6YGZXYKmpo7uyYD1or7su
 relationalai/semantics/std/re.py,sha256=xMuQY5sG3fEL1efHDNFnVpnXVkDJMmDVUEbHiPr1oqA,4375
 relationalai/semantics/std/strings.py,sha256=w0k06gDfyMS6GODPjhG0gl2SkJ0aH5aYezS8jG9jsU8,5617
 relationalai/shims/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-relationalai/shims/executor.py,sha256=NegQJqrEXWEQVfhy7FzF_oGazf0IHvVNCiDMX1z4Ws0,6755
+relationalai/shims/executor.py,sha256=KKPno0Jfeb8KK9jSdLl-T5EeBkcxWDC7HDUcMxTQkw4,7405
 relationalai/shims/helpers.py,sha256=1v6D-wDq3nCwDz4egdGUeleRC0fK6wfo9fIQIeQCfZA,4508
 relationalai/shims/hoister.py,sha256=YXXi9pWpKQ7Sd5DzRVl_78z4OYCoKzFfIMMp6OIN3EM,8797
-relationalai/shims/mm2v0.py,sha256=oksKidw6dU1r5Aq99uuv-Y1nLCG17FXEzsx2GqY_xGw,59702
+relationalai/shims/mm2v0.py,sha256=xt08HGv06ABxR1u1EZsdDc_2qVuNw5XNLQ8HKuK_YxU,63715
 relationalai/tools/debugger.py,sha256=B8QIE1-WFdfkiPoFFn1yztr9t6yf5PI32Y9Y9XzQOJk,10798
 relationalai/tools/typer_debugger.py,sha256=__oLODEBwgt6pYIn1jgIPlenFmiK7iqXfTY_mozHxXA,3182
 relationalai/tools/cli/__init__.py,sha256=jkIlp7wftUuSIlczwZD4_siT5cs6mzpsNGrQ_kMkLZ4,74
@@ -72,7 +72,7 @@ v0/relationalai/debugging.py,sha256=AuzbwLT1s71tctuIbYNhfWY2vR_opB7ItbmlqFVHgrY,
 v0/relationalai/dependencies.py,sha256=tL113efcISkJUiDXYHmRdU_usdD7gmee-VRHA7N4EFA,16574
 v0/relationalai/docutils.py,sha256=1gVv9mk0ytdMB2W7_NvslJefmSQtTOg8LHTCDcGCjyE,1554
 v0/relationalai/dsl.py,sha256=9BdpqzDNcW4717GyxVAYIMZ7ctE_bvXS-5sNLIbXQZ0,66128
-v0/relationalai/errors.py,sha256=V7CzFJf2L5g348luz8ZA9PyB3YKAg8DDF7spi66gKsY,94951
+v0/relationalai/errors.py,sha256=2rFE3tWDhhZ3GCzG1UNuCkns3xxsscUU6wx_3VvoVWI,95976
 v0/relationalai/metagen.py,sha256=o10PNvR_myr_61DC8g6lkB093bFo9qXGUkZKgKyfXiE,26821
 v0/relationalai/metamodel.py,sha256=P1hliwHd1nYxbXON4LZeaYZD6T6pZm97HgmFBFrWyCk,32886
 v0/relationalai/rel.py,sha256=ePmAXx4NxOdsPcHNHyGH3Jkp_cB3QzfKu5p_EQSHPh0,38293
@@ -357,17 +357,17 @@ v0/relationalai/semantics/devtools/compilation_manager.py,sha256=DDHY5DNwRK0hD9P
 v0/relationalai/semantics/devtools/extract_lqp.py,sha256=Ccvhw3W-8VHYi2Kui64lCUmCrliygGqFc6C0LQlvgWM,3702
 v0/relationalai/semantics/internal/__init__.py,sha256=BS0WE1GbT-HpQ5p_zMr9Fcvph562WMvMQNI9czfKNt0,798
 v0/relationalai/semantics/internal/annotations.py,sha256=PkrRN-gHO2ksh1hDKB1VVIB39dONvLdTd8_Y0rCR3fE,367
-v0/relationalai/semantics/internal/internal.py,sha256=pGF0kaQoYcwTQ-lq9G_QHyR78K1KFIcapcBtnNkefa4,150789
-v0/relationalai/semantics/internal/snowflake.py,sha256=Sk-dRruRz69ZZc0fQQygW6MZSnTWQOzX8r-MPCyTqBA,13494
+v0/relationalai/semantics/internal/internal.py,sha256=-juUQ8AL1kAoh6PgpBQJ5Jp3qjwSgjx64s3IKeKXVYk,150821
+v0/relationalai/semantics/internal/snowflake.py,sha256=Zw-jC2XmsWwZlOn_5zwfu_gCxs-dH0XlSOcAELAc70k,13588
 v0/relationalai/semantics/lqp/__init__.py,sha256=XgcQZxK-zz_LqPDVtwREhsIvjTuUIt4BZhIedCeMY-s,48
 v0/relationalai/semantics/lqp/builtins.py,sha256=Xst9-UxkCAwDqL-hFOby8B3GKh705oidFUjEozxn71Y,585
 v0/relationalai/semantics/lqp/compiler.py,sha256=xpGIQAqTMwLi3Vrbe79Yal7O_mfNxpBLioZjqeV2hzc,955
 v0/relationalai/semantics/lqp/constructors.py,sha256=x7G85vbJzLIXzUCMKVdJVsr4PrcUsAOzCCfvimHLMVU,2366
-v0/relationalai/semantics/lqp/executor.py,sha256=65xRwmCVqqcNB3f_s9c4XFnQ3xsjQTJlBpGEhm-4-cM,21651
+v0/relationalai/semantics/lqp/executor.py,sha256=DeZw71K3TAXI8mZDWa4c9N3V3HQfOVn1YNIPhuKcFcU,21875
 v0/relationalai/semantics/lqp/intrinsics.py,sha256=8kgH4ndYKBCNnoNOn7iWOU0wnMTSiov0kYaKocQ45RY,880
 v0/relationalai/semantics/lqp/ir.py,sha256=6W9mUH0W7u5eIfF1S3o33uSOfQuM3UcqEkxrxpr1X_8,1867
-v0/relationalai/semantics/lqp/model2lqp.py,sha256=5xOMSXvrActc3G3zddMyn0osviPOW7Mq_G-H2EZ21zs,36990
-v0/relationalai/semantics/lqp/passes.py,sha256=hMOXbztIiyhy95bD5M7Ru91eiscIQhZkiXOejsMqjRc,28642
+v0/relationalai/semantics/lqp/model2lqp.py,sha256=J_QofcYgq_Yb5dhOOP4lXvxsxFMEGHVnaNXoCMK_ak8,38639
+v0/relationalai/semantics/lqp/passes.py,sha256=Jwj6VgTU9jyp6oVTqUpFKa7ZjFRbc7HWNLmJiKf389w,28652
 v0/relationalai/semantics/lqp/pragmas.py,sha256=FzzldrJEAZ1AIcEw6D-FfaVg3CoahRYgPCFo7xHfg1g,375
 v0/relationalai/semantics/lqp/primitives.py,sha256=OxdcCx-0528113CrR2Ia-ZE0lewCmOCS1fezPwvmYa0,11044
 v0/relationalai/semantics/lqp/result_helpers.py,sha256=ArYlBafNL2zB4ipwhQWiwVSOXp3lp0DefICFHxw9_mc,10135
@@ -376,15 +376,15 @@ v0/relationalai/semantics/lqp/utils.py,sha256=T9Ic_38iNc9DW3ufdHTMpRSoaFM_Mw_2_V
 v0/relationalai/semantics/lqp/validators.py,sha256=-tapIMa9Hq-qlRP_Vr03_jIkH6RTERnSKdWbrxdWbhQ,1564
 v0/relationalai/semantics/lqp/rewrite/__init__.py,sha256=V9ERED9qdh4VvY9Ud_M8Zn8lhVANdOGIgW03l55sGj0,492
 v0/relationalai/semantics/lqp/rewrite/annotate_constraints.py,sha256=zOm-OUzWBhk2iMc_eURII1-okIGJ-teDbEcJ30WDjUU,2325
-v0/relationalai/semantics/lqp/rewrite/cdc.py,sha256=tX5vcf6ULm7eFwOxfyT4EfbCSXLcaSrrLJqVy1IbGPo,10402
+v0/relationalai/semantics/lqp/rewrite/cdc.py,sha256=cx_fpQrzkzkeAGHE_kV10nd1-0Jduws6yiIRq650f4c,10412
 v0/relationalai/semantics/lqp/rewrite/extract_common.py,sha256=johHGsS9SDDVbonMIE8Ck9rCuidllwdeJZDruW_5kQs,14705
-v0/relationalai/semantics/lqp/rewrite/extract_keys.py,sha256=tLo9GSmplDM1TrwbMfYNS4lI1zQKpuSzMHa4E6-aD9M,19332
+v0/relationalai/semantics/lqp/rewrite/extract_keys.py,sha256=lDO1e5pC_Z-nYMXt5zeLBxWQUjNgkhLMiaRLYkF7ZqU,21070
 v0/relationalai/semantics/lqp/rewrite/function_annotations.py,sha256=WAHpqRVBqpUIDL2MA1aBmyOTvcpH_yfdeWBS1vAEtzA,4675
 v0/relationalai/semantics/lqp/rewrite/functional_dependencies.py,sha256=LTwMvU19FMdgCG8nJwV2wyiW8Hu9oCj-hIKKSMOYZYE,12727
 v0/relationalai/semantics/lqp/rewrite/quantify_vars.py,sha256=3l_pDMc4r-izuE274MP_ffNgZ6g7Rk5ysg3CXqKKlBU,12016
 v0/relationalai/semantics/lqp/rewrite/splinter.py,sha256=ggZ41OjaT8GA-CgUejbJfR7G6vZB6EmNY-WqyQxgeok,3205
 v0/relationalai/semantics/metamodel/__init__.py,sha256=I-XqQAGycD0nKkKYvnF3G9d0QK_1LIM4xXICw8g8fBA,805
-v0/relationalai/semantics/metamodel/builtins.py,sha256=O26klqMH4ud5nqb2Os6ISsxaPsCj5X1eVKD5RuGUmtA,38657
+v0/relationalai/semantics/metamodel/builtins.py,sha256=HN-F5lpnwZiMsl2kBUxdXDSa3LPjVDUIuPF0AbbgqNU,39024
 v0/relationalai/semantics/metamodel/compiler.py,sha256=YRRqvA_PJeE02P0IVte4gQtolqgBVu9HEhwOgf4WKuY,4534
 v0/relationalai/semantics/metamodel/dataflow.py,sha256=wfj1tARrR4yEAaTwUTrAcxEcz81VkUal4U_AX1esovk,3929
 v0/relationalai/semantics/metamodel/dependency.py,sha256=khgS8DitIYxbgfMeJ5NP-ZCf7zMOagAgpPfQ9IOTzWc,33932
@@ -399,7 +399,7 @@ v0/relationalai/semantics/metamodel/rewrite/__init__.py,sha256=9ONWFSdMPHkWpObDM
 v0/relationalai/semantics/metamodel/rewrite/discharge_constraints.py,sha256=jilU6ZNaqhoFRwNdxArSfYb3Rbeahig9kDjdYoJR9Q4,1955
 v0/relationalai/semantics/metamodel/rewrite/dnf_union_splitter.py,sha256=TZykhhhwkYQsJjNxDac0YY4A6bmzOrNKJwB1LFQOsb4,8001
 v0/relationalai/semantics/metamodel/rewrite/extract_nested_logicals.py,sha256=i5KSANUCtI5Gq03cMiJv0lR4-0M5qc7gu50gsReo72I,3369
-v0/relationalai/semantics/metamodel/rewrite/flatten.py,sha256=HN8X4JXvSwJiljMWaV3x8iDeLOYg2ZC5O0AbqQym8QE,22528
+v0/relationalai/semantics/metamodel/rewrite/flatten.py,sha256=fi4blz2P1ZE0Y70b29fLS69QXcr-g3HGhDCzaM-C6tk,22846
 v0/relationalai/semantics/metamodel/rewrite/format_outputs.py,sha256=MDDa48LFk3M5NF02h18Ej3wgODg8cF2CRFAZiRNZnhk,6240
 v0/relationalai/semantics/metamodel/typer/__init__.py,sha256=E3ydmhWRdm-cAqWsNR24_Qd3NcwiHx8ElO2tzNysAXc,143
 v0/relationalai/semantics/metamodel/typer/checker.py,sha256=XzvGAZWmJGHuZ0XHGc8-dy9uIWrwZsIWi1v1_4TzKKQ,19190
@@ -407,7 +407,7 @@ v0/relationalai/semantics/metamodel/typer/typer.py,sha256=2_eKanWV5xVnAwUlIcbXQM
 v0/relationalai/semantics/reasoners/__init__.py,sha256=SmcmkK5TqMjGzDZjFIbkYwaMuQe9y09NaAyWrIMG60Y,306
 v0/relationalai/semantics/reasoners/experimental/__init__.py,sha256=ZWXb3Oun7m_G2c3ijKnqxbEsAzTMVa7ciBXjdi4dCNI,144
 v0/relationalai/semantics/reasoners/graph/__init__.py,sha256=7G6M2c0eBbsxtP9iq7E6y02wBJlD6GxsLeDPAJPJ1MM,1285
-v0/relationalai/semantics/reasoners/graph/core.py,sha256=PFBQl3RoiQZk8P6aglPo-vuPdilbpix4YcEEtbgN9Ko,399548
+v0/relationalai/semantics/reasoners/graph/core.py,sha256=Bth2oe5ulItBChZCoFTgP-oPMbnCNp7Ln8G8P5FZlTk,399513
 v0/relationalai/semantics/reasoners/optimization/__init__.py,sha256=HZlyy3Od7ArXI_HMhWrxrQPnyZGScgiVdmMul51lx7Q,2218
 v0/relationalai/semantics/reasoners/optimization/common.py,sha256=gmJrJAPNyaBqik2_QaxjCoFPZKqdroxmNXUeoDGwOtY,3130
 v0/relationalai/semantics/reasoners/optimization/solvers_dev.py,sha256=MqCvdDk1l_XSBlHd5-XpHVfcvD8INjCNbCttaomv6SY,24517
@@ -420,7 +420,7 @@ v0/relationalai/semantics/rel/rel.py,sha256=mQTykcHz63P1w8nhvA8SwYRtIi0LEud19vGr
 v0/relationalai/semantics/rel/rel_utils.py,sha256=B9qR7hUouybwluuo9zUYemv6tWPnDPaV4da-emsTrRQ,9569
 v0/relationalai/semantics/snowflake/__init__.py,sha256=QRcuGvnK-TeNOWvHpBu5Z4hJHcMRXb5IPOokvLihy1U,169
 v0/relationalai/semantics/sql/__init__.py,sha256=59uuKmQOFUzwlYwc7anSuwhQ45bJTYVmd9nOJXr9mQs,80
-v0/relationalai/semantics/sql/compiler.py,sha256=wVLKx26Lfb3yqpcBZsDc6f0xVvg1N2omQ7em4UnZVA8,129198
+v0/relationalai/semantics/sql/compiler.py,sha256=dars-hVkUytvwtNaWh6FC_NM2XSUY2UkipDQ8i-sc2c,129230
 v0/relationalai/semantics/sql/sql.py,sha256=a3EBJKPp92EoVpl1qct2jdBwXQflFpG1nJ2OLNc5go8,17125
 v0/relationalai/semantics/sql/executor/__init__.py,sha256=F3HqQPJVP9wgV3rkwI5jy1_QBCD_3qj2IGxbdT_pX9k,120
 v0/relationalai/semantics/sql/executor/duck_db.py,sha256=FriWhN_IvpQ1YH0YcQ9vlnPRkM1ARoqKDZd0koSk0SM,1918
@@ -482,8 +482,8 @@ v0/relationalai/util/span_tracker.py,sha256=7vyvEBdI9uCj1dxVZCQT_W5vPMxIzxewrlRR
 v0/relationalai/util/spans_file_handler.py,sha256=w34WVw19ubtrjPBkKmg0Hb-9MldICmowF1OW85KCJN0,3209
 v0/relationalai/util/timeout.py,sha256=2o6BVNFnFc-B2j-i1pEkZcQbMRto9ps2emci0XwiA4I,783
 v0/relationalai/util/tracing_handler.py,sha256=wJQN52PRw8R2XB1_qd-POgfGZStrj9OFL7wa5Xr6SEM,1732
-relationalai-1.0.0a1.dist-info/METADATA,sha256=EGwVxgfa8vs2t23NVNdD-17Tq0nWXPBF-EQnKFqbu4g,1368
-relationalai-1.0.0a1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-relationalai-1.0.0a1.dist-info/entry_points.txt,sha256=u_anMN5_VCOQNA5E2mTLT2LWc9r1i-F9yQmy3ZNAAck,91
-relationalai-1.0.0a1.dist-info/top_level.txt,sha256=Y9cfzWf-p2omqqmVy_98m287xf0OJbj6OB5RRdkGql4,16
-relationalai-1.0.0a1.dist-info/RECORD,,
+relationalai-1.0.0a2.dist-info/METADATA,sha256=j3ofGijkfDIsTfki1G_l7ycajPA4m9hLrUWYIuNI9dg,1368
+relationalai-1.0.0a2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+relationalai-1.0.0a2.dist-info/entry_points.txt,sha256=u_anMN5_VCOQNA5E2mTLT2LWc9r1i-F9yQmy3ZNAAck,91
+relationalai-1.0.0a2.dist-info/top_level.txt,sha256=Y9cfzWf-p2omqqmVy_98m287xf0OJbj6OB5RRdkGql4,16
+relationalai-1.0.0a2.dist-info/RECORD,,

v0/relationalai/errors.py

@@ -2168,6 +2168,29 @@ class DirectAccessInvalidAuthWarning(RAIWarning):
         Direct access requires one of the following authenticators: {valid_authenticators_str}
         """)
 
+class NonDefaultLQPSemanticsVersionWarning(RAIWarning):
+    def __init__(self, current_version: str, default_version: str):
+        self.current_version = current_version
+        self.default_version = default_version
+        self.name = "Non-default LQP Semantics Version"
+        self.message = f"Using non-default LQP semantics version {current_version}. Default is {default_version}."
+        self.content = self.format_message()
+        super().__init__(self.message, self.name, self.content)
+
+    def format_message(self):
+        return textwrap.dedent(f"""
+        {self.message}
+
+        You are using a non-default LQP semantics version, likely to avoid a change in
+        behaviour that broke one of your models. This is a reminder to ensure you switch
+        back to the default version once any blocking issues have been resolved.
+
+        To do so you need to remove the following section from your raiconfig.toml:
+
+        [reasoner.rule]
+        lqp.semantics_version = {self.current_version}
+        """)
+
 class InsecureKeychainWarning(RAIWarning):
     def __init__(self):
         self.message = "Insecure keyring detected. Please use a secure keyring backend."

v0/relationalai/semantics/internal/internal.py

@@ -884,12 +884,12 @@ class Concept(Producer):
             raise ValueError("Concept names cannot start with '_'")
 
         # Check if it matches either allowed format
-        pattern_a = r'^[a-zA-Z0-9_.]+$'
-        pattern_b = r'^[a-zA-Z0-9_.]+\([0-9]+,[0-9]+\)$'
+        pattern_a = r'^[a-zA-Z0-9_."-]+$'
+        pattern_b = r'^[a-zA-Z0-9_."-]+\([0-9]+,[0-9]+\)$'
 
         if not (re.match(pattern_a, name) or re.match(pattern_b, name)):
             raise ValueError(f"Concept name '{name}' contains invalid characters. "
-                           f"Names must contain only letters, digits, dots, and underscores, "
+                           f"Names must contain only letters, digits, dots, double quotes, hyphens, and underscores, "
                            f"optionally followed by precision/scale in parentheses like 'Decimal(38,14)'")
 
     def __init__(self, name:str, extends:list[Any] = [], model:Model|None=None, identify_by:dict[str, Any]={}):
@@ -1365,7 +1365,7 @@ class Relationship(Producer):
 
     def _parse_schema_format(self, format_string:str):
         # Pattern to extract fields like {Type} or {name:Type}, where Type can have precision and scale, like Decimal(38,14)
-        pattern = r'\{([a-zA-Z0-9_.]+(?:\([0-9]+,[0-9]+\))?)(?::([a-zA-Z0-9_.]+(?:\([0-9]+,[0-9]+\))?))?\}'
+        pattern = r'\{([a-zA-Z0-9_."-]+(?:\([0-9]+,[0-9]+\))?)(?::([a-zA-Z0-9_."-]+(?:\([0-9]+,[0-9]+\))?))?\}'
         matches = re.findall(pattern, format_string)
 
         namer = NameCache()

v0/relationalai/semantics/internal/snowflake.py

@@ -230,7 +230,8 @@ class Table():
         if self._table not in schema_info.fetched:
             schema_info.fetch()
         table_info = schema_info.tables[self._table]
-        self._rel = b.Relationship(self._fqn, fields=[b.Field(name="RowId", type_str=self._fqn, type=self._concept)] + table_info.fields)
+        CDC_name = self._fqn.lower() if '"' not in self._fqn else self._fqn.replace("\"", "_")
+        self._rel = b.Relationship(CDC_name, fields=[b.Field(name="RowId", type_str=self._fqn, type=self._concept)] + table_info.fields)
         self._rel.annotate(anns.external).annotate(anns.from_cdc)
 
     def __getattr__(self, name: str):

v0/relationalai/semantics/lqp/executor.py

@@ -10,6 +10,7 @@ from snowflake.snowpark import Session
 import v0.relationalai as rai
 
 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
 from v0.relationalai.semantics.lqp.compiler import Compiler
@@ -29,6 +30,9 @@ from v0.relationalai.tools.query_utils import prepare_metadata_for_headers
 if TYPE_CHECKING:
     from v0.relationalai.semantics.snowflake import Table
 
+# 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"
 
 class LQPExecutor(e.Executor):
     """Executes LQP using the RAI client."""
@@ -147,17 +151,7 @@ class LQPExecutor(e.Executor):
                 elif code == "PYREL_ERROR":
                     pyrel_errors[problem["props"]["pyrel_id"]].append(problem)
                 elif abort_on_error:
-                    e = errors.RelQueryError(problem, source)
-
-                    if code == 'SYSTEM_INTERNAL':
-                        supplementary_message = "Troubleshooting:\n" + \
-                            "  1. Please retry with a new name for your model. This can work around state-related issues.\n" + \
-                            "  2. If the error persists, please retry with the `use_lqp` flag set to `False`, for example:\n" + \
-                            "       `model = Model(..., use_lqp=False)`\n" + \
-                            "     This will switch the execution to the legacy backend, which may avoid the issue with some performance cost.\n"
-
-                        e.content = f"{e.content}{supplementary_message}"
-                    all_errors.append(e)
+                    all_errors.append(errors.RelQueryError(problem, source))
             else:
                 if code == "ARITY_MISMATCH":
                     errors.ArityMismatch(problem, source)
@@ -311,6 +305,17 @@ class LQPExecutor(e.Executor):
         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)
+
+        # Set semantics_version from config, defaulting to 0
+        semantics_version: str | Any = self.config.get('reasoner.rule.lqp.semantics_version', DEFAULT_LQP_SEMANTICS_VERSION)
+        config_dict['semantics_version'] = lqp_ir.Value(value=int(semantics_version), meta=None)
+
+        # Warn if a non-default semantics version is used. Most likely, this is due to a
+        # user manually reverting to an older version. We want them to not get stuck on that
+        # version for longer than necessary.
+        if semantics_version != DEFAULT_LQP_SEMANTICS_VERSION:
+            debugging.warn(NonDefaultLQPSemanticsVersionWarning(semantics_version, DEFAULT_LQP_SEMANTICS_VERSION))
+
         return construct_configure(config_dict, None)
 
     def _should_sync(self, model) :