relationalai 0.9.17__tar.gz → 0.9.18__tar.gz

{relationalai-0.9.17 → relationalai-0.9.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 0.9.17
+Version: 0.9.18
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
 License-File: LICENSE

{relationalai-0.9.17 → relationalai-0.9.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = 'relationalai'
-version = '0.9.17'
+version = '0.9.18'
 description = 'RelationalAI Library and CLI'
 readme="docs/pypi/README.md"
 authors = [

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/clients/snowflake.py

@@ -702,22 +702,14 @@ Otherwise, remove it from your '{profile}' configuration profile.
         self._create_engine(name, size, auto_suspend_mins, True)
 
     def delete_engine(self, name:str, force:bool = False, headers: Dict | None = None):
-        request_headers = {}
-        prop_headers = debugging.gen_current_propagation_headers()
-        if headers:
-            request_headers.update(headers)
-        request_headers.update(prop_headers)
+        request_headers = debugging.add_current_propagation_headers(headers)
         self._exec(f"call {APP_NAME}.api.delete_engine('{name}', {force},{request_headers});")
 
     def suspend_engine(self, name:str):
         self._exec(f"call {APP_NAME}.api.suspend_engine('{name}');")
 
     def resume_engine(self, name:str, headers: Dict | None = None) -> Dict:
-        request_headers = {}
-        prop_headers = debugging.gen_current_propagation_headers()
-        if headers:
-            request_headers.update(headers)
-        request_headers.update(prop_headers)
+        request_headers = debugging.add_current_propagation_headers(headers)
         self._exec(f"call {APP_NAME}.api.resume_engine('{name}',{request_headers});")
         # returning empty dict to match the expected return type
         return {}
@@ -1559,12 +1551,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
     ):
         if inputs is None:
             inputs = {}
-        prop_headers = debugging.generate_propagation_headers(debugging.get_current_span())
-        request_headers = {}
-        if headers:
-            request_headers.update(headers)
-        request_headers.update(prop_headers)
-
+        request_headers = debugging.add_current_propagation_headers(headers)
         query_attrs_dict = json.loads(request_headers.get("X-Query-Attributes", "{}"))
 
         with debugging.span("transaction", **query_attrs_dict) as txn_span:
@@ -2980,7 +2967,6 @@ class DirectAccessClient:
         return url, ep.method
 
     def _prepare_headers(self, headers: Dict[str, str] | None) -> Dict[str, str]:
-
         request_headers = {}
         if headers:
             request_headers.update(headers)
@@ -2994,7 +2980,8 @@ class DirectAccessClient:
 
         request_headers["user-agent"] = get_pyrel_version(self.generation)
         request_headers["pyrel_program_id"] = debugging.get_program_span_id() or ""
-        return request_headers
+
+        return debugging.add_current_propagation_headers(request_headers)
 
 class DirectAccessResources(Resources):
     """

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/clients/use_index_poller.py

@@ -142,7 +142,10 @@ class UseIndexPoller:
                 "should_check_cdc": self.should_check_cdc,
                 "init_engine_async": self.init_engine_async,
             })
-            sql_string = f"CALL {self.app_name}.api.use_index([{sources_object_references_str}], PARSE_JSON(?), {self.headers});"
+
+            request_headers = debugging.add_current_propagation_headers(self.headers)
+
+            sql_string = f"CALL {self.app_name}.api.use_index([{sources_object_references_str}], PARSE_JSON(?), {request_headers});"
 
             with debugging.span("wait", counter=self.counter, use_index_id=use_index_id) as span:
                 results = self.res._exec(sql_string, [params])

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/debugging.py

@@ -4,7 +4,7 @@ import contextlib
 import datetime
 import json
 import os
-from typing import Dict, Generator
+from typing import Dict, Generator, Optional
 import logging
 import uuid
 import warnings
@@ -212,6 +212,15 @@ class Span:
             "attrs": self.attrs,
         }
 
+
+def add_current_propagation_headers(headers: Optional[Dict]) -> Dict:
+    prop_headers = gen_current_propagation_headers()
+
+    if headers:
+        prop_headers.update(headers)        
+
+    return prop_headers
+
 def gen_current_propagation_headers():
     return generate_propagation_headers(get_current_span())
 

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/early_access/builder/builder/__init__.py

@@ -2,7 +2,7 @@ import warnings
 
 from relationalai.semantics.internal.internal import (field_to_type, Compiler, RelationshipRef, ConceptNew,
                                                       RelationshipFieldRef, Ref, Aggregate, decimal_concept_by_name,
-                                                      _global_id)
+                                                      _global_id, TupleArg)
 from relationalai.semantics.internal import (
     Model, Concept, Relationship, RelationshipReading, Expression, Fragment, Error, Field,
     String, Integer, Int64, Int128, Float, Decimal, Bool,
@@ -24,7 +24,7 @@ __all__ = [
     "count", "sum", "min", "max", "avg", "per",
     "not_", "builder",
     "field_to_type", "Compiler", "RelationshipRef", "ConceptNew", "RelationshipFieldRef", "Ref", "Aggregate",
-    "decimal_concept_by_name", "_global_id"
+    "decimal_concept_by_name", "_global_id", "TupleArg"
 ]
 
 warnings.warn(

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/early_access/dsl/orm/models.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 from collections import OrderedDict
 from typing import Optional, Any, Sequence, Union, TypeVar
 
-import relationalai.early_access.builder as qb
+import relationalai.semantics as qb
+from relationalai.semantics.std import constraints as c
 from relationalai import Config
 from relationalai.early_access.dsl.bindings.common import Binding
 from relationalai.early_access.dsl.bindings.csv import CsvTable
@@ -75,6 +76,7 @@ class Model:
     def unique(self, *roles):
         uc = Unique(*roles)
         self.constraint(uc)
+        c.unique(*roles)
         first_part_of = roles[0]._part_of()
         if isinstance(first_part_of, RelationshipReading):
             relationship = first_part_of._alt_of
@@ -82,20 +84,7 @@ class Model:
             relationship = first_part_of
         # check if UC is internal
         if all(role._part_of()._id == first_part_of._id for role in roles):
-            field_refs = set(r._field_ref for r in roles)
             internal_ucs = self._relationship_iuc.get(relationship, [])
-            # create sets of ref fields declared for the relationship
-            iuc_ref_sets = [set(r._field_ref for r in uc.roles()) for uc in internal_ucs]
-            for reading in relationship._readings:
-                refs_except_last = set(reading._field_refs[:-1])
-                # when internal UC declared for all the roles except the last one in the RelationshipReading mark RelationshipReading as `is_many=False`
-                if field_refs == refs_except_last:
-                    reading._is_many = False
-                elif not reading._is_many:
-                    # check that a reading already has an internal uc with the roles except the last one
-                    # if not then mark reading as `is_many=True`
-                    if all(refs != refs_except_last for refs in iuc_ref_sets):
-                        reading._is_many = True
             internal_ucs.append(uc)
             self._relationship_iuc[relationship] = internal_ucs  # todo: this logic should be part of reactive reasoner
 

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/internal/internal.py

@@ -20,7 +20,7 @@ from relationalai.clients.config import Config
 from relationalai.clients.result_helpers import Int128Dtype
 from relationalai.semantics.metamodel import factory as f, helpers, ir, builtins, types
 from relationalai.semantics.metamodel.typer import typer
-from relationalai.semantics.metamodel.util import NameCache, OrderedSet, ordered_set
+from relationalai.semantics.metamodel.util import NameCache, OrderedSet, ordered_set, FrozenOrderedSet
 from relationalai.semantics.rel.executor import RelExecutor
 from relationalai.semantics.lqp.executor import LQPExecutor
 from relationalai.semantics.sql.executor import SnowflakeExecutor
@@ -507,10 +507,16 @@ class Producer:
     def _get_relationship(self, name:str) -> Relationship|RelationshipRef|RelationshipFieldRef:
         root_type:Concept = to_type(self) or Concept.builtins["Any"]
         namer = NameCache()
-        r = Relationship(
+        cls = Relationship if root_type is Error else Property
+        r = cls(
             f"{{{root_type}}} has {{{name}:Any}}",
-            parent=self, short_name=name, model=self._model,
-            field_refs=cast(list[Ref], [root_type.ref(namer.get_name(1, root_type._name.lower())), Concept.builtins["Any"].ref(namer.get_name(2, name))])
+            parent=self,
+            short_name=name,
+            model=self._model,
+            field_refs=cast(list[Ref], [
+                root_type.ref(namer.get_name(1, root_type._name.lower())),
+                Concept.builtins["Any"].ref(namer.get_name(2, name)),
+            ]),
         )
         # if we don't know the root type, then this relationship is unresolved and we're
         # really just handing an anonymous relationship back that we expect to be resolved
@@ -839,9 +845,9 @@ class Concept(Producer):
                 if python_types_to_concepts.get(v):
                     v = python_types_to_concepts[v]
                 if isinstance(v, Concept):
-                    setattr(self, k, Relationship(f"{{{self._name}}} has {{{k}:{v._name}}}", short_name=k, model=self._model))
+                    setattr(self, k, Property(f"{{{self._name}}} has {{{k}:{v._name}}}", short_name=k, model=self._model))
                 elif isinstance(v, type) and issubclass(v, self._model.Enum): #type: ignore
-                    setattr(self, k, Relationship(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}}}", short_name=k, model=self._model))
                 elif isinstance(v, Relationship):
                     self._validate_identifier_relationship(v)
                     setattr(self, k, v)
@@ -865,7 +871,7 @@ class Concept(Producer):
         self._check_ref_scheme(kwargs, shallow=True)
         return ConceptConstruct(self, args, kwargs)
 
-    def annotate(self, *annos:Expression|Relationship) -> Concept:
+    def annotate(self, *annos:Expression|Relationship|ir.Annotation) -> Concept:
         self._annotations.extend(annos)
         return self
 
@@ -1175,7 +1181,7 @@ class Field():
 class Relationship(Producer):
     builtins = {}
 
-    def __init__(self, madlib:str, parent:Producer|None=None, short_name:str="", model:Model|None=None, fields:list[Field]|None=None, field_refs:list[Ref]|None=None, is_many:bool|None=None, ir_relation:ir.Relation|None=None):
+    def __init__(self, madlib:str, parent:Producer|None=None, short_name:str="", model:Model|None=None, fields:list[Field]|None=None, field_refs:list[Ref]|None=None, ir_relation:ir.Relation|None=None):
         found_model = model or find_model(parent) or find_model(args)
         super().__init__(found_model)
         self._parent = parent
@@ -1185,7 +1191,7 @@ class Relationship(Producer):
         if fields is not None:
             self._fields:list[Field] = fields
         else:
-            self._fields, is_many = self._parse_schema_format(madlib)
+            self._fields = self._parse_schema_format(madlib)
         if not self._fields and not ir_relation:
             raise ValueError(f"No fields found in relationship {self}")
         self._ir_relation = ir_relation
@@ -1196,8 +1202,9 @@ class Relationship(Producer):
             self._field_refs = [cast(Ref, field_to_type(found_model, field).ref(field.name)) for field in self._fields]
         for field in self._field_refs:
             field._no_lookup = True
+        self._internal_constraints:set[FieldsConstraint] = set()
         self._field_names = [field.name for field in self._fields]
-        self._readings = [RelationshipReading(madlib, alt_of=self, short_name=short_name, fields=self._fields, is_many=is_many, model=found_model, parent=parent)]
+        self._readings = [RelationshipReading(madlib, alt_of=self, short_name=short_name, fields=self._fields, model=found_model, parent=parent)]
         self._annotations = []
         # now that the Relationship is validated, register into the model
         if found_model is not None:
@@ -1212,33 +1219,30 @@ class Relationship(Producer):
         return self._passed_short_name or _short_name_from_madlib(self._madlib)
 
     def is_many(self):
-        return self._readings[0].is_many()
+        if self._arity() == 1:
+            return False
+        uc = Unique.to_identity(*(self[i] for i in range(self._arity() - 1)))
+        return uc not in self._internal_constraints
 
     def _is_filter(self) -> bool:
         return self._short_name in [">", "<", "=", "!=", ">=", "<="]
 
     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 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]+\))?))?\}'
         matches = re.findall(pattern, format_string)
 
         namer = NameCache()
         fields = []
-        is_many = False
         match_index = 0
         ix = 0
-        for field_name, field_name_is_many, field_type, field_type_is_many in matches:
+        for field_name, field_type in matches:
             # If no type is specified, use the field name as the type
             if not field_type:
                 field_type = field_name
                 # in this case, the field_name is based on the type name, so sanitize to avoid
                 # ()s in decimal names, for example
                 field_name = helpers.sanitize(field_name.lower())
-                field_type_is_many = field_name_is_many
-
-            is_many = bool(field_type_is_many)
-            if is_many and match_index != len(matches) - 1:
-                raise ValueError(f"Only the last role of a relationship reading can be 1-to-many: {format_string}")
 
             ix += 1
             field_name = namer.get_name(ix, field_name)
@@ -1246,7 +1250,7 @@ class Relationship(Producer):
             fields.append(Field(field_name, field_type))
             match_index +=1
 
-        return fields, is_many
+        return fields
 
     def _dir_extras_from_get_relationship(self) -> Any:
         return self._field_refs[-1]._dir_extras_from_getattr()
@@ -1270,7 +1274,7 @@ class Relationship(Producer):
             return RelationshipFieldRef(self._parent, self, self._field_names.index(name))
         return super().__getattr__(name)
 
-    def annotate(self, *annos:Expression|Relationship) -> Relationship:
+    def annotate(self, *annos:Expression|Relationship|ir.Annotation) -> Relationship:
         self._annotations.extend(annos)
         return self
 
@@ -1318,18 +1322,16 @@ class Relationship(Producer):
 
 class Property(Relationship):
 
-    def __init__(self, madlib:str, parent:Producer|None=None, short_name:str="", model:Model|None=None, fields:list[Field]|None=None, field_refs:list[Ref]|None=None, is_many:bool|None=None, ir_relation:ir.Relation|None=None):
-        super().__init__(madlib, parent, short_name, model, fields, field_refs, is_many, ir_relation)
+    def __init__(self, madlib:str, parent:Producer|None=None, short_name:str="", model:Model|None=None, fields:list[Field]|None=None, field_refs:list[Ref]|None=None, ir_relation:ir.Relation|None=None):
+        super().__init__(madlib, parent, short_name, model, fields, field_refs, ir_relation)
         # for property should be an implicit unique constraint on the first n-1 fields
         uc = Unique(*(self[i] for i in range(self._arity() - 1)), model=self._model)
         require(uc.to_expressions())
 
 
 class RelationshipReading(Producer):
-    # if true, the last role has 1-many semantics
-    _is_many:bool = False
 
-    def __init__(self, madlib:str, alt_of:Relationship, short_name:str, fields:list[Field]|None=None, is_many:bool|None=None, model:Model|None=None, parent:Producer|None=None,):
+    def __init__(self, madlib:str, alt_of:Relationship, short_name:str, fields:list[Field]|None=None, model:Model|None=None, parent:Producer|None=None,):
         found_model = model or find_model(parent)
         super().__init__(found_model)
         self._parent = parent
@@ -1338,9 +1340,8 @@ class RelationshipReading(Producer):
         self._passed_short_name = short_name
         if fields is not None:
             self._fields:list[Field] = fields
-            self._is_many = is_many or False
         else:
-            self._fields, self._is_many = alt_of._parse_schema_format(madlib)
+            self._fields = alt_of._parse_schema_format(madlib)
         if Counter(self._fields) != Counter(alt_of._fields):
             raise ValueError(
                 f"Invalid alternative relationship. The alternative group of used fields ({', '.join(str(f) for f in self._fields)}) does not match with the original ({', '.join(str(f) for f in alt_of._fields)})")
@@ -1350,12 +1351,15 @@ class RelationshipReading(Producer):
         self._annotations = []
 
     def is_many(self):
-        return self._is_many
+        if self._arity() == 1:
+            return False
+        uc = Unique.to_identity(*(self[i] for i in range(self._arity() - 1)))
+        return uc not in self._alt_of._internal_constraints
 
     def _arity(self):
         return len(self._fields)
 
-    def annotate(self, *annos:Expression|Relationship) -> RelationshipReading:
+    def annotate(self, *annos:Expression|Relationship|ir.Annotation) -> RelationshipReading:
         self._annotations.extend(annos)
         return self
 
@@ -1553,7 +1557,9 @@ class ConceptExpression(Expression):
                 args[rel] = kwargs[rel._short_name]
         else:
             for k, v in kwargs.items():
-                args[getattr(self._op, k)] = v
+                atr = getattr(self._op, k)
+                if atr:
+                    args[atr] = v
             if ident:
                 args[self._op] = ident
         return args
@@ -2021,14 +2027,17 @@ class FieldsConstraint:
     def fields(self) -> tuple[RelationshipFieldRef, ...]:
         return self._fields
 
-    def __init__(self, *fields: RelationshipFieldRef, model:Model|None=None):
-        self._fields = fields
+    def __init__(self, *fields: RelationshipFieldRef, model:Model|None=None) -> None:
+        self._init_constraint(*fields)
         self._model = model or find_model(fields)
+        if self._model:
+            self._model.constraints.add(self)
+
+    def _init_constraint(self, *fields: RelationshipFieldRef) -> None:
+        self._fields = fields
         ids = [field._field_ref._id for field in fields]
         ids.sort()  # ensures order doesn't matter
         self._id = f'{type(self).__name__}:{ids}'
-        if self._model:
-            self._model.constraints.add(self)
 
     def __eq__(self, other):
         if isinstance(other, FieldsConstraint):
@@ -2038,11 +2047,21 @@ class FieldsConstraint:
     def __hash__(self):
         return hash(self._id)
 
+    @classmethod
+    def to_identity(cls, *fields: RelationshipFieldRef):
+        obj = cls.__new__(cls)
+        obj._init_constraint(*fields)
+        return obj
+
 class Unique(FieldsConstraint):
 
-    def __init__(self, *fields: RelationshipFieldRef, model:Model|None=None):
-        self._internal = all(fields[0]._relationship._is_same_relationship(f._relationship) for f in fields[1:])
+    def __init__(self, *fields: RelationshipFieldRef, model:Model|None=None) -> None:
+        first_field_rel = fields[0]._relationship
+        self._internal = all(first_field_rel._is_same_relationship(f._relationship) for f in fields[1:])
         super().__init__(*fields, model=model)
+        if self._internal:
+            relationship = first_field_rel._alt_of if isinstance(first_field_rel, RelationshipReading) else first_field_rel
+            relationship._internal_constraints.add(self)
 
     def internal(self) -> bool:
         return self._internal
@@ -2146,7 +2165,7 @@ class Fragment():
         self._meta.update(kwargs)
         return self
 
-    def annotate(self, *annos:Expression|Relationship) -> Fragment:
+    def annotate(self, *annos:Expression|Relationship|ir.Annotation) -> Fragment:
         self._annotations.extend(annos)
         return self
 
@@ -2771,6 +2790,20 @@ class Compiler():
                 else:
                     final_keys.update(keys)
 
+            # If we are exporting into a table, we need to add a key to the output
+            # We hash all the values to create a key
+            if not final_keys and fragment._is_export:
+                tmp_var = ctx.to_value(self)
+                assert isinstance(tmp_var, ir.Var)
+                key_var = f.var(tmp_var.name, types.Hash)
+                assert isinstance(key_var, ir.Var)
+                final_keys.add(key_var)
+                values = [ir.Literal(types.String, "NO_KEYS")]
+                for fld in fields:
+                    values.append(fld[1])
+                con = ir.Construct(None, tuple(values), key_var, FrozenOrderedSet([]))
+                ctx.add(con)
+
             ctx.add(f.output(fields, keys=list(final_keys), annos=annos))
 
     def require(self, fragment:Fragment, items:PySequence[Expression], ctx:CompilerContext):
@@ -3261,7 +3294,7 @@ class Compiler():
 
             ctx.add(f.derive(relation, [out]))
             # derive the membership and all the relationships
-            rels = self.relation_dict({getattr(item._op, k): v for k, v in kwargs.items()}, ctx)
+            rels = self.relation_dict({attr: v for k, v in kwargs.items() if (attr := getattr(item._op, k, None)) is not None}, ctx)
             for k, v in rels.items():
                 assert not isinstance(v, list)
                 ctx.add(f.derive(k, [out, v]))

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/internal/snowflake.py

@@ -262,10 +262,12 @@ class Table():
         else:
             me = self._rel._field_refs[0]
             b.where(self).define(concept(me))
+        # if there are no keys all the fields must be properties
+        rel_func = b.Relationship if keys else b.Property
         for field in self._rel._fields[1:]:
             field_name = sanitize_identifier(field.name.lower())
             if field_name not in key_dict:
-                r = b.Relationship(
+                r = rel_func(
                     f"{{{concept}}} has {{{field_name}:{field.type_str}}}",
                     parent=concept,
                     short_name=field_name,

relationalai-0.9.18/src/relationalai/semantics/lqp/builtins.py

@@ -0,0 +1,14 @@
+from relationalai.semantics.metamodel import factory as f
+from relationalai.semantics.metamodel.util import FrozenOrderedSet
+from relationalai.semantics.metamodel import builtins
+
+# Indicates a relation is short-lived, thus, backends should not optimize for incremental
+# maintenance.
+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([
+    adhoc.name,
+    builtins.function.name,
+])

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/lqp/constructors.py

@@ -61,3 +61,6 @@ def mk_primitive(name: str, terms: list[lqp.RelTerm]) -> lqp.Primitive:
 
 def mk_pragma(name: str, terms: list[lqp.Var]) -> lqp.Pragma:
     return lqp.Pragma(name=name, terms=terms, meta=None)
+
+def mk_attribute(name: str, args: list[lqp.Value]) -> lqp.Attribute:
+    return lqp.Attribute(name=name, args=args, meta=None)

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/lqp/model2lqp.py

@@ -1,12 +1,13 @@
-from relationalai.semantics.metamodel import ir, builtins as rel_builtins, helpers, types
+from relationalai.semantics.metamodel import ir, builtins, helpers, types
 from relationalai.semantics.metamodel.visitor import collect_by_type
-from relationalai.semantics.lqp import ir as lqp, utils, types as lqp_types
+from relationalai.semantics.metamodel.util import FrozenOrderedSet
+from relationalai.semantics.lqp import ir as lqp, utils, types as lqp_types, builtins as lqp_builtins
 from relationalai.semantics.lqp.primitives import lqp_avg_op, lqp_operator, build_primitive
 from relationalai.semantics.lqp.pragmas import pragma_to_lqp_name
 from relationalai.semantics.lqp.types import meta_type_to_lqp
 from relationalai.semantics.lqp.constructors import (
     mk_abstraction, mk_and, mk_exists, mk_or, mk_pragma, mk_primitive,
-    mk_specialized_value, mk_type, mk_value, mk_var
+    mk_specialized_value, mk_type, mk_value, mk_var, mk_attribute
 )
 from relationalai.semantics.lqp.utils import TranslationCtx, gen_unique_var
 from relationalai.semantics.lqp.validators import assert_valid_input
@@ -14,6 +15,7 @@ from relationalai.semantics.lqp.validators import assert_valid_input
 from decimal import Decimal as PyDecimal
 from datetime import datetime, date
 from typing import Tuple, cast, Union, Optional
+from warnings import warn
 import re
 import uuid
 
@@ -134,6 +136,23 @@ def _translate_to_decls(ctx: TranslationCtx, rule: ir.Logical) -> list[lqp.Decla
 
     return [_translate_effect(ctx, effect, mk_and(conjuncts)) for effect in effects]
 
+def _translate_annotations(annotations: FrozenOrderedSet[ir.Annotation]) -> list[lqp.Attribute]:
+    attributes = []
+    for annotation in annotations:
+
+        if annotation.relation.name in lqp_builtins.annotations_to_emit:
+            if any(not isinstance(a, ir.Literal) for a in annotation.args):
+                warn("LQP currently ignores annotation parameters with non-literal values")
+                continue
+
+            # Convert literal arguments to LQP values
+            args = []
+            for a in annotation.args:
+                assert isinstance(a, ir.Literal)
+                args.append(mk_value(a.value))
+            attributes.append(mk_attribute(annotation.relation.name, args))
+    return attributes
+
 # Translates an effect (export, output, or update) into the corresponding def. Note that
 # this method only generates the def and not the LQP read operation, which is added later by
 # `_get_output_reads` and `_get_export_reads`.
@@ -141,7 +160,7 @@ def _translate_effect(ctx: TranslationCtx, effect: Union[ir.Output, ir.Update],
     bindings = _effect_bindings(effect)
 
     def _is_export(e):
-        return isinstance(e, ir.Output) and rel_builtins.export_annotation in e.annotations
+        return isinstance(e, ir.Output) and builtins.export_annotation in e.annotations
 
     if isinstance(effect, ir.Output):
         projection, eqs, suffix = _translate_output_bindings(ctx, bindings)
@@ -179,7 +198,9 @@ def _translate_effect(ctx: TranslationCtx, effect: Union[ir.Output, ir.Update],
     return lqp.Def(
         name = rel_id,
         body = mk_abstraction(projection, new_body),
-        attrs = [],
+        # TODO this only covers the annotations on the effect itself. Annotations on the
+        # relation are not included yet.
+        attrs = _translate_annotations(effect.annotations),
         meta = None,
     )
 
@@ -457,10 +478,7 @@ def _translate_to_formula(ctx: TranslationCtx, task: ir.Task) -> lqp.Formula:
         return mk_exists(lqp_vars, mk_and(conjuncts))
     elif isinstance(task, ir.Construct):
         assert len(task.values) >= 1, "Construct should have at least one value"
-        assert isinstance(task.values[0], ir.ScalarType), "Construct should start with a named ScalarType"
-        name = task.values[0].name
-        terms = [_translate_term(ctx, ir.Literal(types.String, name))]
-        terms.extend([_translate_term(ctx, arg) for arg in task.values[1:]])
+        terms = [_translate_term(ctx, arg) for arg in task.values]
         result_term = _translate_term(ctx, task.id_var)
         terms.append(result_term)
         assert result_term[1].type_name == lqp.TypeName.UINT128, \
@@ -494,7 +512,10 @@ def _translate_relterm(ctx: TranslationCtx, term: ir.Value) -> Tuple[lqp.RelTerm
     return _translate_term(ctx, term)
 
 def _translate_term(ctx: TranslationCtx, term: ir.Value) -> Tuple[lqp.Term, lqp.Type]:
-    if isinstance(term, ir.Var):
+    if isinstance(term, ir.ScalarType):
+        # TODO: ScalarType is not like other terms, should be handled separately.
+        return to_lqp_value(term.name, types.String), meta_type_to_lqp(types.String)
+    elif isinstance(term, ir.Var):
         name = ctx.var_names.get_name_by_id(term.id, term.name)
         t = meta_type_to_lqp(term.type)
         return mk_var(name), t
@@ -504,7 +525,7 @@ def _translate_term(ctx: TranslationCtx, term: ir.Value) -> Tuple[lqp.Term, lqp.
         return v, meta_type_to_lqp(term.type)
 
 def _translate_to_atom(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
-    if task.relation == rel_builtins.cast:
+    if task.relation == builtins.cast:
         assert len(task.args) == 3, f"expected three terms for {task.relation.name}, got {len(task.args)}"
 
         terms = []
@@ -529,11 +550,11 @@ def _translate_to_atom(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
             terms.append(term)
             term_types.append(ty)
 
-    if rel_builtins.is_pragma(task.relation):
+    if builtins.is_pragma(task.relation):
         lqp_name = pragma_to_lqp_name(task.relation.name)
         return mk_pragma(lqp_name, terms)
 
-    if rel_builtins.is_builtin(task.relation):
+    if builtins.is_builtin(task.relation):
         return build_primitive(task.relation.name, terms, term_types)
 
     if helpers.is_external(task.relation):

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/lqp/passes.py

@@ -19,9 +19,9 @@ def lqp_passes() -> list[Pass]:
     return [
         FDConstraints(),
         Checker(),
+        CDC(), # specialize to physical relations before extracting nested and typing
         ExtractNestedLogicals(), # before InferTypes to avoid extracting casts
         InferTypes(),
-        CDC(),
         DNFUnionSplitter(),
         ExtractKeys(),
         # Broken

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/metamodel/builtins.py

@@ -27,6 +27,9 @@ lte = _comparator("<=")
 neq = _comparator("!=")
 eq = _comparator("=", False)
 
+def is_eq(other: ir.Relation) -> bool:
+    return other == eq or other in eq.overloads
+
 # Arithmetic operators
 def _binary_op(name: str, with_string=False, result_type: Optional[ir.Type]=None):
     overload_types = [types.Int64, types.Int128, types.Float, types.GenericDecimal]

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/metamodel/dependency.py

@@ -622,7 +622,7 @@ class BindingAnalysis(visitor.Visitor):
             if isinstance(child, ir.Lookup):
                     # special case eq because it can be input or output
                     # TODO: this is similar to what's done below in visit_lookup, modularize
-                    if child.relation == builtins.eq:
+                    if builtins.is_eq(child.relation):
                         x, y = child.args[0], child.args[1]
                         if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
                             grounds.add(x)
@@ -748,7 +748,7 @@ class BindingAnalysis(visitor.Visitor):
                 else:
                     self.output(node, arg)
 
-        if node.relation == builtins.eq:
+        if builtins.is_eq(node.relation):
             # special case eq because it can be input or output
             x, y = node.args[0], node.args[1]
             if isinstance(x, ir.Var) and not isinstance(y, ir.Var):

{relationalai-0.9.17 → relationalai-0.9.18}/src/relationalai/semantics/metamodel/helpers.py

@@ -82,7 +82,7 @@ def get_outputs(lookup: ir.Lookup):
         Return an array with the arguments of this lookup that are referring to output fields
         on the relation being looked up.
     """
-    if lookup.relation == builtins.eq:
+    if builtins.is_eq(lookup.relation):
         # special case eq because it can be input or output
         x, y = lookup.args[0], lookup.args[1]
         if isinstance(x, ir.Var) and not isinstance(y, ir.Var):