relationalai 0.12.9__py3-none-any.whl → 0.12.11__py3-none-any.whl

relationalai/semantics/internal/internal.py

@@ -621,7 +621,7 @@ class Producer:
 
                 if self._model and self._model._strict:
                     raise AttributeError(f"{self._name} has no relationship `{name}`")
-                if topmost_parent is not concept:
+                if topmost_parent is not concept and topmost_parent not in Concept.builtin_concepts:
                     topmost_parent._relationships[name] = topmost_parent._get_relationship(name)
                     rich.print(f"[red bold][Implicit Subtype Relationship][/red bold] [yellow]{concept}.{name}[/yellow] appended to topmost parent [yellow]{topmost_parent}[/yellow] instead")
 
@@ -1165,7 +1165,10 @@ Primitive = Concept.builtins["Primitive"] = Concept("Primitive")
 Error = Concept.builtins["Error"] = ErrorConcept("Error")
 
 def _register_builtin(name):
-    c = Concept(name, extends=[Primitive])
+    if name == "AnyEntity":
+        c = Concept(name)
+    else:
+        c = Concept(name, extends=[Primitive])
     Concept.builtin_concepts.add(c)
     Concept.builtins[name] = c
 
@@ -1174,6 +1177,7 @@ for builtin in types.builtin_types:
     if isinstance(builtin, ir.ScalarType):
         _register_builtin(builtin.name)
 
+AnyEntity = Concept.builtins["AnyEntity"]
 Float = Concept.builtins["Float"]
 Number = Concept.builtins["Number"]
 Int64 = Concept.builtins["Int64"]
@@ -2896,10 +2900,9 @@ class Compiler():
                 if concept not in self.types:
                     self.to_type(concept)
                     self.to_relation(concept)
-                if concept._extends:
-                    rule = self.concept_inheritance_rule(concept)
-                    if rule:
-                        rules.append(rule)
+                rule = self.concept_inheritance_rule(concept)
+                if rule:
+                    rules.append(rule)
         unresolved = []
         for relationship in model.relationships:
             if relationship not in self.relations:
@@ -3204,8 +3207,11 @@ class Compiler():
         # filter extends to get only non-primitive parents
         parents = []
         for parent in concept._extends:
-            if not parent._is_primitive():
+            if not parent._is_primitive() and parent is not AnyEntity:
                 parents.append(parent)
+        # always extend AnyEntity for non-primitive types that are not built-in
+        if not concept._is_primitive() and concept not in Concept.builtin_concepts:
+            parents.append(AnyEntity)
         # only extends primitive types, no need for inheritance rules
         if not parents:
             return None
@@ -3218,6 +3224,17 @@ class Compiler():
             *[f.derive(self.to_relation(parent), [var]) for parent in parents]
         ])
 
+    def concept_any_entity_rule(self, entities:list[Concept]):
+        """
+        Generate an inheritance rule for all these entities to AnyEntity.
+        """
+        any_entity_relation = self.to_relation(AnyEntity)
+        var = f.var("v", types.Any)
+        return f.logical([
+            f.union([f.lookup(self.to_relation(e), [var]) for e in entities]),
+            f.derive(any_entity_relation, [var])
+        ])
+
     def relation_dict(self, items:dict[Relationship|Concept, Producer], ctx:CompilerContext) -> dict[ir.Relation, list[ir.Var]]:
         return {self.to_relation(k): unwrap_list(self.lookup(v, ctx)) for k, v in items.items()}
 

relationalai/semantics/lqp/README.md

@@ -0,0 +1,34 @@
+# Logic Engine LQP Backend
+
+The logic engine runs the *Logical Query Protocol* (short *LQP*). This module includes a
+compiler from the semantic metamodel to LQP along with an executor.
+
+## Running against a local logic engine
+
+For development and testing, it is possible to run PyRel models against a local logic engine
+server process.
+
+To start your local server, please refer to the [logic engine
+docs](https://github.com/RelationalAI/raicode/tree/master/src/Server#starting-the-server).
+
+With the local server running, add this to your `raiconfig.toml`:
+
+```toml
+[profile.local]
+platform = "local"
+engine = "local"
+host = "localhost"
+port = 8010
+```
+
+Then set `active_profile = "local"` at the top of the file.
+
+**Known limitations:**
+
+Local execution does not support running against Snowflake source tables.
+
+At the moment, locally created databases cannot be cleaned up by the client. Eventually you
+will need to clear your local pager directory.
+
+At the moment, local execution is only supported for fast-path transactions, i.e. those
+which complete in less than 5 seconds. Polling support will be added soon.

relationalai/semantics/lqp/constructors.py

@@ -63,5 +63,6 @@ def mk_attribute(name: str, args: list[lqp.Value]) -> lqp.Attribute:
 def mk_transaction(
     epochs: list[lqp.Epoch],
     configure: lqp.Configure = lqp.construct_configure({}, None),
+    sync = None
 ) -> lqp.Transaction:
-    return lqp.Transaction(epochs=epochs, configure=configure, meta=None)
+    return lqp.Transaction(epochs=epochs, configure=configure, sync=sync, meta=None)

relationalai/semantics/lqp/executor.py

@@ -66,6 +66,8 @@ class LQPExecutor(e.Executor):
                 resource_class = rai.clients.snowflake.Resources
                 if self.config.get("use_direct_access", USE_DIRECT_ACCESS):
                     resource_class = rai.clients.snowflake.DirectAccessResources
+                if self.config.get("platform", "") == "local":
+                    resource_class = rai.clients.local.LocalResources
                 # NOTE: language="lqp" is not strictly required for LQP execution, but it
                 # will significantly improve performance.
                 self._resources = resource_class(
@@ -311,6 +313,12 @@ class LQPExecutor(e.Executor):
             config_dict['ivm.maintenance_level'] = lqp_ir.Value(value=ivm_flag, meta=None)
         return construct_configure(config_dict, None)
 
+    def _should_sync(self, model) :
+        if self._last_model != model:
+            return lqp_ir.Sync(fragments=[], meta=None)
+        else :
+            return None
+
     def _compile_intrinsics(self) -> lqp_ir.Epoch:
         """Construct an epoch that defines a number of built-in definitions used by the
         emitter."""
@@ -334,6 +342,7 @@ class LQPExecutor(e.Executor):
                 meta=None,
             )
 
+    # [RAI-40997] We eagerly undefine query fragments so they are not committed to storage
     def _compile_undefine_query(self, query_epoch: lqp_ir.Epoch) -> lqp_ir.Epoch:
         fragment_ids = []
 
@@ -363,7 +372,9 @@ class LQPExecutor(e.Executor):
         epochs = []
         epochs.append(self._compile_intrinsics())
 
-        if self._last_model != model:
+        sync = self._should_sync(model)
+
+        if sync is not None:
             with debugging.span("compile", metamodel=model) as install_span:
                 install_span["compile_type"] = "model"
                 _, model_epoch = self.compiler.compile(model, {"fragment_id": b"model"})
@@ -383,7 +394,7 @@ class LQPExecutor(e.Executor):
             epochs.append(self._compile_undefine_query(query_epoch))
 
             txn_span["compile_type"] = "query"
-            txn = mk_transaction(epochs=epochs, configure=configure)
+            txn = mk_transaction(epochs=epochs, configure=configure, sync=sync)
             txn_span["lqp"] = lqp_print.to_string(txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
 
         validate_lqp(txn)

relationalai/semantics/lqp/ir.py

@@ -4,6 +4,7 @@ __all__ = [
     "SourceInfo",
     "LqpNode",
     "Declaration",
+    "FunctionalDependency",
     "Def",
     "Loop",
     "Abstraction",
@@ -45,6 +46,7 @@ __all__ = [
     "Read",
     "Epoch",
     "Transaction",
+    "Sync",
     "DebugInfo",
     "Configure",
     "IVMConfig",
@@ -59,6 +61,7 @@ from lqp.ir import (
     SourceInfo,
     LqpNode,
     Declaration,
+    FunctionalDependency,
     Def,
     Loop,
     Abstraction,
@@ -100,6 +103,7 @@ from lqp.ir import (
     Read,
     Epoch,
     Transaction,
+    Sync,
     DebugInfo,
     Configure,
     IVMConfig,

relationalai/semantics/lqp/model2lqp.py

@@ -11,7 +11,9 @@ from relationalai.semantics.lqp.constructors import (
 )
 from relationalai.semantics.lqp.utils import TranslationCtx, gen_unique_var
 from relationalai.semantics.lqp.validators import assert_valid_input
-
+from relationalai.semantics.lqp.rewrite.functional_dependencies import (
+    normalized_fd, contains_only_declarable_constraints
+)
 from decimal import Decimal as PyDecimal
 from datetime import datetime, date, timezone
 from typing import Tuple, cast, Union, Optional
@@ -102,6 +104,43 @@ def _get_export_reads(export_ids: list[tuple[lqp.RelationId, int, lqp.Type]]) ->
     return (export_filename, col_info, reads)
 
 def _translate_to_decls(ctx: TranslationCtx, rule: ir.Logical) -> list[lqp.Declaration]:
+    if contains_only_declarable_constraints(rule):
+        return _translate_to_constraint_decls(ctx, rule)
+    else:
+        return _translate_to_standard_decl(ctx, rule)
+
+def _translate_to_constraint_decls(ctx: TranslationCtx, rule: ir.Logical) -> list[lqp.Declaration]:
+    constraint_decls: list[lqp.Declaration] = []
+    for task in rule.body:
+        assert isinstance(task, ir.Require)
+        fd = normalized_fd(task)
+        assert fd is not None
+
+        # check for unresolved types
+        if any(types.is_any(var.type) for var in fd.keys + fd.values):
+            warn(f"Ignoring FD with unresolved type: {fd}")
+            continue
+
+        lqp_typed_keys = [_translate_term(ctx, key) for key in fd.keys]
+        lqp_typed_values = [_translate_term(ctx, value) for value in fd.values]
+        lqp_typed_vars:list[Tuple[lqp.Var, lqp.Type]] = lqp_typed_keys + lqp_typed_values # type: ignore
+        lqp_guard_atoms = [_translate_to_atom(ctx, atom) for atom in fd.guard]
+        lqp_guard = mk_abstraction(lqp_typed_vars, mk_and(lqp_guard_atoms))
+        lqp_keys:list[lqp.Var] = [var for (var, _) in lqp_typed_keys] # type: ignore
+        lqp_values:list[lqp.Var] = [var for (var, _) in lqp_typed_values] # type: ignore
+
+        fd_decl = lqp.FunctionalDependency(
+            guard=lqp_guard,
+            keys=lqp_keys,
+            values=lqp_values,
+            meta=None
+        )
+
+        constraint_decls.append(fd_decl)
+
+    return constraint_decls
+
+def _translate_to_standard_decl(ctx: TranslationCtx, rule: ir.Logical) -> list[lqp.Declaration]:
     effects = collect_by_type((ir.Output, ir.Update), rule)
     aggregates = collect_by_type(ir.Aggregate, rule)
     ranks = collect_by_type(ir.Rank, rule)
@@ -452,7 +491,7 @@ def _translate_aggregate(ctx: TranslationCtx, aggr: ir.Aggregate, body: lqp.Form
 
         return mk_exists(result_terms, conjunction)
 
-    # `input_args`` hold the types of the input arguments, but they may have been modified
+    # `input_args` hold the types of the input arguments, but they may have been modified
     # if we're dealing with a count, so we use `abstr_args` to find the type.
     (aggr_arg, aggr_arg_type) = abstr_args[-1]
 

relationalai/semantics/lqp/passes.py

@@ -6,9 +6,11 @@ from relationalai.semantics.metamodel.util import FrozenOrderedSet
 
 from relationalai.semantics.metamodel.rewrite import Flatten
 
-from ..metamodel.rewrite import DischargeConstraints, DNFUnionSplitter, ExtractNestedLogicals, FormatOutputs
-from .rewrite import CDC, ExtractCommon, ExtractKeys, FunctionAnnotations, QuantifyVars, Splinter, SplitMultiCheckRequires
-
+from ..metamodel.rewrite import DNFUnionSplitter, ExtractNestedLogicals, FormatOutputs
+from .rewrite import (
+    AnnotateConstraints, CDC, ExtractCommon, ExtractKeys, FunctionAnnotations, QuantifyVars,
+    Splinter, SplitMultiCheckRequires
+)
 from relationalai.semantics.lqp.utils import output_names
 
 from typing import cast, List, Sequence, Tuple, Union, Optional, Iterable
@@ -20,7 +22,7 @@ def lqp_passes() -> list[Pass]:
     return [
         SplitMultiCheckRequires(),
         FunctionAnnotations(),
-        DischargeConstraints(),
+        AnnotateConstraints(),
         Checker(),
         CDC(), # specialize to physical relations before extracting nested and typing
         ExtractNestedLogicals(), # before InferTypes to avoid extracting casts

relationalai/semantics/lqp/rewrite/__init__.py

@@ -1,3 +1,4 @@
+from .annotate_constraints import AnnotateConstraints
 from .cdc import CDC
 from .extract_common import ExtractCommon
 from .extract_keys import ExtractKeys
@@ -6,6 +7,7 @@ from .quantify_vars import QuantifyVars
 from .splinter import Splinter
 
 __all__ = [
+    "AnnotateConstraints",
     "CDC",
     "ExtractCommon",
     "ExtractKeys",

relationalai/semantics/lqp/rewrite/annotate_constraints.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from relationalai.semantics.metamodel import builtins
+from relationalai.semantics.metamodel.ir import Node, Model, Require
+from relationalai.semantics.metamodel.compiler import Pass
+from relationalai.semantics.metamodel.rewrite.discharge_constraints import (
+    DischargeConstraintsVisitor
+)
+from relationalai.semantics.lqp.rewrite.functional_dependencies import (
+    is_valid_unique_constraint, normalized_fd
+)
+
+
+
+class AnnotateConstraints(Pass):
+    """
+    Extends `DischargeConstraints` pass by discharging only those Require nodes that cannot
+    be declared as constraints in LQP.
+
+    More precisely, the pass annotates Require nodes depending on how they should be
+    treated when generating code:
+     * `@declare_constraint` if the Require represents a constraint that can be declared in LQP.
+     * `@discharge` if the Require represents a constraint that should be dismissed during
+       code generation. Namely, when it cannot be declared in LQP and uses one of the
+       `unique`, `exclusive`, `anyof` builtins. These nodes are removed from the IR model
+       in the Flatten pass.
+    """
+
+    def rewrite(self, model: Model, options: dict = {}) -> Model:
+        return AnnotateConstraintsRewriter().walk(model)
+
+
+class AnnotateConstraintsRewriter(DischargeConstraintsVisitor):
+    """
+    Visitor marks all nodes which should be removed from IR model with `discharge` annotation.
+    """
+
+    def _should_be_declarable_constraint(self, node: Require) -> bool:
+        if not is_valid_unique_constraint(node):
+            return False
+        # Currently, we only declare non-structural functional dependencies.
+        fd = normalized_fd(node)
+        assert fd is not None  # already checked by _is_valid_unique_constraint
+        return not fd.is_structural
+
+    def handle_require(self, node: Require, parent: Node):
+        if self._should_be_declarable_constraint(node):
+            return node.reconstruct(
+                node.engine,
+                node.domain,
+                node.checks,
+                node.annotations | [builtins.declare_constraint_annotation]
+            )
+
+        return super().handle_require(node, parent)

relationalai/semantics/lqp/rewrite/extract_keys.py

@@ -249,6 +249,24 @@ class ExtractKeysRewriter(Rewriter):
 
         return f.logical(tuple(outer_body), [])
 
+    def noop_logical(self, node: ir.Logical) -> bool:
+        # logicals that don't hoist variables are essentially filters like lookups
+        if not node.hoisted:
+            return True
+        if len(node.body) != 1:
+            return False
+        inner = node.body[0]
+        if not isinstance(inner, (ir.Match, ir.Union)):
+            return False
+        outer_vars = helpers.hoisted_vars(node.hoisted)
+        inner_vars = helpers.hoisted_vars(inner.hoisted)
+        for v in outer_vars:
+            if v not in inner_vars:
+                return False
+        # all vars hoisted by the outer logical, are also
+        # hoisted by the inner Match/Union
+        return True
+
     # compute inital information that's needed for later steps. E.g., what's nullable or
     # not, do some output columns have a default value, etc.
     def preprocess_logical(self, node: ir.Logical, output_keys: Iterable[ir.Var]):
@@ -264,10 +282,11 @@ class ExtractKeysRewriter(Rewriter):
                 non_nullable_vars.update(vars)
                 top_level_tasks.add(task)
             elif isinstance(task, ir.Logical):
-                # logicals that don't hoist variables are essentially filters like lookups
-                if not task.hoisted:
+                if self.noop_logical(task):
                     top_level_tasks.add(task)
-                    # TODO: should we do something about the inner variables?
+                    non_nullable_vars.update(helpers.hoisted_vars(task.hoisted))
+                    continue
+
                 for h in task.hoisted:
                     # Hoisted vars without a default are not nullable
                     if isinstance(h, ir.Var):

relationalai/semantics/lqp/rewrite/functional_dependencies.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Optional, Sequence
 from relationalai.semantics.internal import internal
 from relationalai.semantics.metamodel.ir import (
-    Require, Logical, Var, Relation, Lookup, ScalarType
+    Node, Require, Logical, Var, Relation, Lookup, ScalarType
 )
 from relationalai.semantics.metamodel import builtins
 
@@ -130,14 +130,16 @@ def _split_unique_require_node(node: Require) -> Optional[tuple[list[Var], list[
         return None
 
     # collect variables
-    all_vars: set[Var] = set()
+    all_vars: list[Var] = []
     for lookup in guard:
         for arg in lookup.args:
             if not isinstance(arg, Var):
                 return None
-            all_vars.add(arg)
+            if arg in all_vars:
+                continue
+            all_vars.append(arg)
 
-    unique_vars: set[Var] = set()
+    unique_vars: list[Var] = []
     if len(unique_atom.args) != 1:
         return None
     if not isinstance(unique_atom.args[0], (internal.TupleArg, tuple)):
@@ -147,10 +149,12 @@ def _split_unique_require_node(node: Require) -> Optional[tuple[list[Var], list[
     for arg in unique_atom.args[0]:
         if not isinstance(arg, Var):
             return None
-        unique_vars.add(arg)
+        if arg in unique_vars:
+            return None
+        unique_vars.append(arg)
 
     # check that unique vars are a subset of other vars
-    if not unique_vars.issubset(all_vars):
+    if not set(unique_vars).issubset(set(all_vars)):
         return None
 
     return list(all_vars), list(unique_vars), guard
@@ -218,10 +222,10 @@ class FunctionalDependency:
      - `X` and `Y` are disjoint and covering sets of variables used in `φ`
     """
     def __init__(self, guard: Sequence[Lookup], keys: Sequence[Var], values: Sequence[Var]):
-        self.guard = frozenset(guard)
-        self.keys = frozenset(keys)
-        self.values = frozenset(values)
-        assert self.keys.isdisjoint(self.values), "Keys and values must be disjoint"
+        self.guard = tuple(guard)
+        self.keys = tuple(keys)
+        self.values = tuple(values)
+        assert set(self.keys).isdisjoint(set(self.values)), "Keys and values must be disjoint"
 
         # for structural fd check
         self._is_structural:bool = False
@@ -280,3 +284,31 @@ class FunctionalDependency:
             raise ValueError("Functional dependency is not structural")
         assert self._structural_rank is not None
         return self._structural_rank
+
+    def __str__(self) -> str:
+        guard_str = " ∧ ".join([str(atom) for atom in self.guard]).strip()
+        keys_str = ", ".join([str(var) for var in self.keys]).strip()
+        values_str = ", ".join([str(var) for var in self.values]).strip()
+        return f"{guard_str}: {{{keys_str}}} -> {{{values_str}}}"
+
+def contains_only_declarable_constraints(node: Node) -> bool:
+    """
+    Checks whether the input `Logical` node contains only `Require` nodes annotated with
+    `declare_constraint`.
+    """
+    if not isinstance(node, Logical):
+        return False
+    if len(node.body) == 0:
+        return False
+    for task in node.body:
+        if not isinstance(task, Require):
+            return False
+        if not is_declarable_constraint(task):
+            return False
+    return True
+
+def is_declarable_constraint(node: Require) -> bool:
+    """
+    Checks whether the input `Require` node is annotated with `declare_constraint`.
+    """
+    return builtins.declare_constraint_annotation in node.annotations

relationalai/semantics/lqp/rewrite/quantify_vars.py

@@ -5,6 +5,7 @@ from relationalai.semantics.metamodel.compiler import Pass
 from relationalai.semantics.metamodel.visitor import Visitor, Rewriter
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
 from typing import Optional, Any, Tuple, Iterable
+from .functional_dependencies import contains_only_declarable_constraints
 
 class QuantifyVars(Pass):
     """
@@ -67,6 +68,7 @@ class VarScopeInfo(Visitor):
     IGNORED_NODES = (ir.Type,
                     ir.Var, ir.Literal, ir.Relation, ir.Field,
                     ir.Default, ir.Output, ir.Update, ir.Aggregate,
+                    ir.Check, ir.Require,
                     ir.Annotation, ir.Rank)
 
     def __init__(self):
@@ -74,6 +76,9 @@ class VarScopeInfo(Visitor):
         self._vars_in_scope = {}
 
     def leave(self, node: ir.Node, parent: Optional[ir.Node]=None):
+        if contains_only_declarable_constraints(node):
+            return node
+
         if isinstance(node, ir.Lookup):
             self._record(node, helpers.vars(node.args))
 
@@ -189,6 +194,9 @@ class FindQuantificationNodes(Visitor):
         self.node_quantifies_vars = {}
 
     def enter(self, node: ir.Node, parent: Optional[ir.Node]=None) -> "Visitor":
+        if contains_only_declarable_constraints(node):
+            return self
+
         if isinstance(node, (ir.Logical, ir.Not)):
             ignored_vars = _ignored_vars(node)
             self._handled_vars.update(ignored_vars)
@@ -202,6 +210,9 @@ class FindQuantificationNodes(Visitor):
         return self
 
     def leave(self, node: ir.Node, parent: Optional[ir.Node]=None) -> ir.Node:
+        if contains_only_declarable_constraints(node):
+            return node
+
         if isinstance(node, (ir.Logical, ir.Not)):
             ignored_vars = _ignored_vars(node)
             self._handled_vars.difference_update(ignored_vars)
@@ -221,6 +232,9 @@ class QuantifyVarsRewriter(Rewriter):
         self.node_quantifies_vars = quant.node_quantifies_vars
 
     def handle_logical(self, node: ir.Logical, parent: ir.Node, ctx:Optional[Any]=None) -> ir.Logical:
+        if contains_only_declarable_constraints(node):
+            return node
+
         new_body = self.walk_list(node.body, node)
 
         if node.id in self.node_quantifies_vars:

relationalai/semantics/lqp/validators.py

@@ -21,6 +21,9 @@ CompilableType = Union[
     # Effects
     ir.Output,
     ir.Update,
+
+    # Constraints
+    ir.Require,
 ]
 
 # Preconditions

relationalai/semantics/metamodel/builtins.py

@@ -524,6 +524,11 @@ recursion_config_annotation = f.annotation(recursion_config, [])
 discharged = f.relation("discharged", [])
 discharged_annotation = f.annotation(discharged, [])
 
+# Require nodes with this annotation will be kept in the final metamodel to be emitted as
+# constraint declarations (LQP)
+declare_constraint = f.relation("declare_constraint", [])
+declare_constraint_annotation = f.annotation(declare_constraint, [])
+
 #
 # Aggregations
 #

relationalai/semantics/metamodel/rewrite/flatten.py

@@ -5,7 +5,7 @@ from typing import Tuple
 
 from relationalai.semantics.metamodel import builtins, ir, factory as f, helpers
 from relationalai.semantics.metamodel.compiler import Pass, group_tasks
-from relationalai.semantics.metamodel.util import OrderedSet, ordered_set, NameCache
+from relationalai.semantics.metamodel.util import NameCache, OrderedSet, ordered_set
 from relationalai.semantics.metamodel import dependency
 from relationalai.semantics.metamodel.typer.typer import to_type
 
@@ -419,9 +419,15 @@ class Flatten(Pass):
     def handle_require(self, req: ir.Require, ctx: Context):
         # only extract the domain if it is a somewhat complex Logical and there's more than
         # one check, otherwise insert it straight into all checks
-        domain = req.domain
-        # only generate logic for not discharged requires
-        if builtins.discharged_annotation not in req.annotations:
+        if builtins.discharged_annotation in req.annotations:
+            # remove discharged Requires
+            return Flatten.HandleResult(None)
+        elif builtins.declare_constraint_annotation in req.annotations:
+            # leave Requires that are declared constraints
+            return Flatten.HandleResult(req)
+        else:
+            # generate logic for remaining requires
+            domain = req.domain
             if len(req.checks) > 1 and isinstance(domain, ir.Logical) and len(domain.body) > 1:
                 body = OrderedSet.from_iterable(domain.body)
                 vars = helpers.hoisted_vars(domain.hoisted)

relationalai/semantics/metamodel/typer/typer.py

@@ -156,6 +156,10 @@ def type_matches(actual:ir.Type, expected:ir.Type, allow_expected_parents=False)
     if actual == types.Any or expected == types.Any:
         return True
 
+    # any entity matches any entity (surprise surprise!)
+    if extends_any_entity(expected) and not is_primitive(actual):
+        return True
+
     # all decimals match across each other
     if types.is_decimal(actual) and types.is_decimal(expected):
         return True
@@ -288,6 +292,15 @@ def is_base_primitive(type:ir.Type) -> bool:
 def is_primitive(type:ir.Type) -> bool:
     return to_base_primitive(type) is not None
 
+def extends_any_entity(type:ir.Type) -> bool:
+    if type == types.AnyEntity:
+        return True
+    if isinstance(type, ir.ScalarType):
+        for parent in type.super_types:
+            if extends_any_entity(parent):
+                return True
+    return False
+
 def invalid_type(type:ir.Type) -> bool:
     if isinstance(type, ir.UnionType):
         # if there are multiple primitives, or a primtive and a non-primitive

relationalai/semantics/metamodel/types.py

@@ -80,6 +80,7 @@ GenericDecimal = ir.ScalarType("GenericDecimal", util.frozen())
 #
 Null = ir.ScalarType("Null", util.frozen())
 Any = ir.ScalarType("Any", util.frozen())
+AnyEntity = ir.ScalarType("AnyEntity", util.frozen())
 Hash = ir.ScalarType("Hash", util.frozen())
 String = ir.ScalarType("String", util.frozen())
 Int64 = ir.ScalarType("Int64")
@@ -144,7 +145,7 @@ def is_null(t: ir.Type) -> bool:
 
 def is_abstract_type(t: ir.Type) -> bool:
     if isinstance(t, ir.ScalarType):
-        return t in [Any, Number, GenericDecimal]
+        return t in [Any, AnyEntity, Number, GenericDecimal]
     elif isinstance(t, ir.ListType):
         return is_abstract_type(t.element_type)
     elif isinstance(t, ir.TupleType):