relationalai 0.13.0.dev0__py3-none-any.whl → 0.13.2__py3-none-any.whl

relationalai/early_access/dsl/core/types/standard.py

@@ -0,0 +1,92 @@
+from relationalai.early_access.dsl.core.types.constrained.subtype import ValueSubtype
+from relationalai.early_access.dsl.core.types.unconstrained import UnconstrainedValueType, UnconstrainedNumericType
+
+standard_value_types = {}
+
+# Hash types
+Hash = UnconstrainedValueType('Hash')
+standard_value_types[Hash.display()] = Hash
+
+# Boolean types
+Boolean = UnconstrainedNumericType('Boolean')
+standard_value_types[Boolean.display()] = Boolean
+
+# Decimal types
+#
+Decimal = UnconstrainedNumericType('Decimal')
+standard_value_types[Decimal.display()] = Decimal
+
+UnsignedDecimal = ValueSubtype('UnsignedDecimal')
+standard_value_types[UnsignedDecimal.display()] = UnsignedDecimal
+with UnsignedDecimal:
+    x = Decimal()
+    x >= 0
+
+PositiveDecimal = ValueSubtype('PositiveDecimal')
+standard_value_types[PositiveDecimal.display()] = PositiveDecimal
+with PositiveDecimal:
+    x = UnsignedDecimal()
+    x != 0
+
+# Floating-point types
+#
+Float = UnconstrainedNumericType('Float')
+standard_value_types[Float.display()] = Float
+Double = UnconstrainedNumericType('Double')  # A float64 in Rel
+standard_value_types[Double.display()] = Double
+
+# Integer types
+#
+BigInteger = UnconstrainedNumericType('BigInteger')  # 128-bit integer
+standard_value_types[BigInteger.display()] = BigInteger
+
+BigUnsignedInteger = ValueSubtype('BigUnsignedInteger')
+standard_value_types[BigUnsignedInteger.display()] = BigUnsignedInteger
+with BigUnsignedInteger:
+    x = BigInteger()
+    x >= 0
+
+BigPositiveInteger = ValueSubtype('BigPositiveInteger')
+standard_value_types[BigPositiveInteger.display()] = BigPositiveInteger
+with BigPositiveInteger:
+    x = BigUnsignedInteger()
+    x != 0
+
+Integer = UnconstrainedNumericType('Integer')
+standard_value_types[Integer.display()] = Integer
+
+UnsignedInteger = ValueSubtype('UnsignedInteger')
+standard_value_types[UnsignedInteger.display()] = UnsignedInteger
+with UnsignedInteger:
+    x = Integer()
+    x >= 0
+
+PositiveInteger = ValueSubtype('PositiveInteger')
+standard_value_types[PositiveInteger.display()] = PositiveInteger
+with PositiveInteger:
+    x = UnsignedInteger()
+    x != 0
+
+# Date types
+#
+Date = UnconstrainedValueType('Date')
+standard_value_types[Date.display()] = Date
+
+# DateTime types
+#
+DateTime = UnconstrainedValueType('DateTime')
+standard_value_types[DateTime.display()] = DateTime
+
+RowId = UnconstrainedNumericType('RowId')
+standard_value_types[RowId.display()] = RowId
+
+# String types
+#
+String = UnconstrainedValueType('String')
+standard_value_types[String.display()] = String
+
+Any = UnconstrainedValueType('Any')
+standard_value_types[Any.display()] = Any
+
+Symbol = UnconstrainedValueType('Symbol')
+standard_value_types[Symbol.display()] = Symbol

relationalai/early_access/dsl/core/types/unconstrained.py

@@ -0,0 +1,50 @@
+from relationalai.early_access.dsl.core.types import AbstractValueType
+from relationalai.early_access.dsl.core.types.variables import BasicTypeVariable
+import numbers
+
+class UnconstrainedValueType(AbstractValueType):
+
+    def __init__(self, nm):
+        AbstractValueType.__init__(self, nm)
+
+    # Returns True if the Python constant `val` is an instance of this ValueType
+    def contains(self, val) -> bool:
+        if isinstance(val, numbers.Number):
+            return self.basic_numeric()
+        elif isinstance(val, str):
+            return not self.basic_numeric()
+        else:
+            return False
+
+    def pprint(self): return self.display()
+
+    def ranges_over(self): return BasicTypeVariable(self)
+
+    def relational(self): return False
+
+    def root_unconstrained_type(self): return self
+
+    def unconstrained(self): return True
+
+class UnconstrainedNumericType(UnconstrainedValueType):
+
+    def __init__(self, nm):
+        UnconstrainedValueType.__init__(self, nm)
+
+    def boolean(self): return self.display() == 'Boolean'
+
+    # For verification purposes, we treat floats ad decimals. While not generally
+    # safe, this is likely fine for constraints we will see in enterprise contexts.
+    #
+    def decimal(self): return self.display() == 'Decimal' or self.display() == 'Float'
+
+    def integer(self): return self.display() == 'Integer' or self.display() == 'BigInteger'
+
+    def basic_numeric(self) -> bool: return True
+
+class UnsupportedUnconstrainedValueType(UnconstrainedValueType):
+    def __init__(self, nm):
+        UnconstrainedValueType.__init__(self, nm)
+
+    def root_unconstrained_type(self):
+        raise Exception(f"Unsupported basic type {self.display()} cannot be the base type of any value type")

relationalai/early_access/dsl/core/types/variables.py

@@ -0,0 +1,203 @@
+from abc import abstractmethod
+from typing import Any
+
+from relationalai.early_access.dsl.core.cset import UnstableConstraintSet
+from relationalai.early_access.dsl.core.exprs.relational import RelationVariable
+from relationalai.early_access.dsl.core.exprs.scalar import ScalarVariable
+
+# We use TypeVariables to formalize the meaning of a ConstrainedValueType.
+# Each represents what would be a variable in a ValueType or ValueSubtype
+# declaration.
+#
+class TypeVariable:
+
+    # Each TypeVariable declares some AbstractValueType (vt) which might
+    # be a ValueSubtype. In addition, each TypeVariable has a Position
+    # that is used to form the name of the variable when needed.
+    #
+    def __init__(self, vt, vmap={}):
+        self.pos = None
+        self._cset = UnstableConstraintSet()
+        self.decl = vt
+        self._vmap = vmap
+
+    # Returns the set of ScalarConstraints that this TypeVariable denotes
+    #
+    def denotes(self, C={}):
+        for sc in self._cset._sconstraints.values():
+            C[sc.entityid()] = sc
+
+        for ac in self._cset._atoms.values():
+            # [REKS] Check the following logic carefully to make sure we don't accidentally
+            #        capture any variable names duirng interpretation of type atoms
+            #
+            scs = self.decl.interpret_type_atom(ac)
+            for s in scs:
+                if s not in C:
+                    C[s] = scs[s]
+        return C
+
+    @abstractmethod
+    def dupe(self, vmap) -> tuple['TypeVariable', Any]: pass
+
+    def setpos(self, pos): pass
+
+    @abstractmethod
+    def varname(self) -> str: pass
+
+class BasicTypeVariable(ScalarVariable, TypeVariable):
+
+    # An UnconstrainedTypeVarible ranges over some UnconstrainedValueType,
+    # which will be the root unconstrained type of vt.
+    #
+    def __init__(self, vt, vmap={}):
+        if vt.nominal():
+            raise Exception(f"Cannot create BasicTypeVariable of nominal type {vt._name}")
+        super().__init__(vt, vmap)
+
+    def display(self):
+        return self.varname()
+
+    def dupe(self, vmap={}):
+        d = BasicTypeVariable(self.decl, vmap)
+        vmap[id(self)] = d
+        cs = self._cset._sconstraints
+        for c in cs.values():
+            newc = c.revar(vmap)
+            d._cset._sconstraints[id(newc)] = newc
+        return (d, vmap)
+
+    def entityid(self):
+        return hash(self.varname())
+
+    def grounded(self):
+        return False
+
+    def grounded_using(self, groundings):
+        return False
+
+    def physical_typeof(self):
+        return self.decl.root_unconstrained_type()
+
+    def rename(self, renaming):
+        nm = self.varname()
+        if nm in renaming:
+            return renaming[nm]
+        else:
+            return self
+
+    def revar(self, vmap):
+        nm = id(self)
+        if nm in vmap:
+            return vmap[nm]
+        else:
+            return self
+
+    def setpos(self, pos):
+        self.pos = pos
+        self._cset = self._cset.stabilize()
+        return pos+1
+
+    def typeof(self):
+        return self.decl
+
+    def typevar_tuple(self):
+        return self
+
+    def varname(self):
+        return f"x{str(self.pos)}"
+
+class NominalTypeVariable(RelationVariable, TypeVariable):
+
+    # If vt is nominal, then the TypeVariable itself is nominal
+    # and ranges over some root nominal ValueType.
+    #
+    def __init__(self, vt, vmap={}):
+        super().__init__(vt, vmap)
+        self._parts = []
+
+    def all_constraint_display(self):
+        parts = [self.constraint_display()]
+        for p in self._parts:
+            if isinstance(p, NominalTypeVariable):
+                parts.append(p.all_constraint_display())
+        return "\n".join(parts)
+
+    def constraint_display(self):
+        parts = [ p.varname() for p in self._parts ]
+        args = ", ".join(parts)
+        return f"   {self.varname()}({args})"
+
+    def denotes(self, C={}):
+        C = super().denotes(C)
+        for p in self._parts:
+            C = p.denotes(C)
+        return C
+
+    def display(self):
+        return self.varname()
+
+    def dupe(self, vmap={}):
+        d = NominalTypeVariable(self.decl, vmap)
+        vmap[id(self)] = d
+
+        for p in self._parts:
+            (pprime, vmap) = p.dupe(vmap)
+            d._parts.append(pprime)
+
+        vmap = d._vmap
+
+        cs = self._cset._sconstraints
+        for c in cs.values():
+            newc = c.revar(vmap)
+            d._cset._sconstraints[id(newc)] = newc
+        acs = self._cset._atoms
+        for ac in acs.values():
+            newac = ac.revar(vmap)
+            d._cset._atoms[id(newac)] = newac
+        return (d, vmap)
+
+    def entityid(self):
+        return hash(self.varname())
+
+    def rename(self, renaming):
+        nm = self.varname()
+        if nm in renaming:
+            return renaming[nm]
+        else:
+            return self
+
+    def revar(self, vmap):
+        nm = id(self)
+        if nm in vmap:
+            return vmap[nm]
+        else:
+            return self
+
+    def setpos(self, pos):
+        self.pos = pos
+        pos = pos + 1
+        for p in self._parts:
+            pos = p.setpos(pos)
+        self._cset = self._cset.stabilize()
+        return pos
+
+    def typeof(self):
+        return self.decl
+
+    def typevar_tuple(self):
+        tvars = []
+
+        for tvar in self._parts:
+            if isinstance(tvar, NominalTypeVariable):
+                tvars.append(tvar.typevar_tuple())
+            else:
+                tvars.append(tvar)
+        if len(tvars) == 1:
+            result = tvars[0]
+        else:
+            result = tuple(tvars)
+        return result
+
+    def varname(self):
+        return f"y{str(self.pos)}"

relationalai/early_access/dsl/ir/compiler.py

@@ -0,0 +1,318 @@
+# type: ignore
+import re
+from typing import Union, Callable, Tuple, List, Optional, Sequence as PySequence
+
+from relationalai.early_access.dsl import Relation, AssertedRelation
+from relationalai.early_access.dsl.core.relations import ExportRelation
+from relationalai.early_access.dsl.ontologies.export import Export
+from relationalai.early_access.dsl.ontologies.raw_source import RawSource
+from relationalai.semantics.metamodel import ir, builtins, types, factory as f
+from relationalai.semantics.metamodel.types import Any, Symbol
+from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
+
+from relationalai.early_access.dsl.core.constraints.predicate.atomic import Atom
+from relationalai.early_access.dsl.core.constraints.scalar import ScalarConstraint
+from relationalai.early_access.dsl.core.exprs import Wildcard
+from relationalai.early_access.dsl.core.exprs.scalar import Literal, BinaryScalarExpr
+from relationalai.early_access.dsl.core.logic import RelVariable
+from relationalai.early_access.dsl.core.logic.aggregation import Aggregation
+from relationalai.early_access.dsl.core.logic.exists import ExistentialConstraint
+from relationalai.early_access.dsl.core.rules import Rule, Annotation
+from relationalai.early_access.dsl.core.types import Type
+from relationalai.early_access.dsl.core.types.standard import Boolean, Hash, Integer, Decimal, Float, Double, \
+    BigInteger, String, Date, DateTime, RowId
+from relationalai.early_access.dsl.ontologies.models import Model
+
+class CompilerContext:
+    def __init__(self):
+        self.var_map:dict[int, ir.Var] = {}
+        self.items:OrderedSet[ir.Task] = OrderedSet()
+        self.project_away_vars_count:int = -1
+        self.project_away_vars:OrderedSet[ir.Var] = OrderedSet()
+
+    def to_var(self, item:Union[RelVariable, Literal], t:Optional[ir.Type] = None) -> ir.Var:
+        entity_id  = item.entityid()
+        if entity_id not in self.var_map:
+            if isinstance(item, RelVariable):
+                self.var_map[entity_id] = f.var(item.display(), t)
+            else:
+                self.var_map[entity_id] = f.lit(item.val)
+        return self.var_map[entity_id]
+
+    def project_away_var_name(self) -> str:
+        self.project_away_vars_count += 1
+        return f"_pa_{self.project_away_vars_count}"
+
+    def to_project_away_var(self, t: ir.Type) -> ir.Var:
+        var = f.var(self.project_away_var_name(), t)
+        self.project_away_vars.add(var)
+        return var
+
+    def add(self, item:ir.Task):
+        self.items.add(item)
+
+    def clone(self):
+        c = CompilerContext()
+        c.var_map = self.var_map.copy()
+        return c
+
+class Compiler:
+    def __init__(self):
+        self.types: dict[Type, ir.Type] = {
+                Hash: f.scalar_type("UInt128"),
+                Boolean: types.Bool,
+                Integer: types.Int128,
+                Decimal: types.Decimal,
+                Float: types.Number,
+                Double: types.Number,
+                String: types.String,
+                BigInteger: f.scalar_type("Int128"),
+                Date: f.scalar_type("Date"),
+                DateTime: f.scalar_type("DateTime"),
+                Symbol: types.Symbol,
+                RowId: types.Sha1,
+                Any: types.Any
+        }
+        self.relations: dict[int, ir.Relation] = {}
+
+    def to_type(self, t: Type) -> ir.Type:
+        if t not in self.types:
+            if t._name in types.builtin_scalar_types_by_name:
+                self.types[t] = types.builtin_scalar_types_by_name[t._name]
+            else:
+                self.types[t] = f.scalar_type(t._name)
+        return self.types[t]
+
+    @staticmethod
+    def _parse_relation_name(name: str, producer: Callable[[str, Any], Union[ir.Field, ir.Var]]) \
+            -> Tuple[str, List[Union[ir.Field, ir.Var]]]:
+        parts = re.split(r'(?<!:):(?!:)', name)
+        if len(parts) > 1:
+            var_list = [producer(f":{part}", types.Symbol) for part in parts[1:]]
+            return parts[0], var_list
+        return name, []
+
+    def to_relation(self, ctx: CompilerContext, item:Atom, name:str) -> ir.Relation:
+        # We use `item.relcomp.entityid()` instead of `item.entityid()`
+        # to ensure that there is only one instance of a relation instead of multiple instances.
+        #
+        # Example:
+        # - `test(x in Int, y in DateTime)`
+        # - `test(y in Int, x in DateTime)`
+        #
+        # These will be considered the same relation.
+        entity_id = item.relcomp.entityid()
+        if entity_id not in self.relations:
+            if name in builtins.builtin_relations_by_name:
+                self.relations[entity_id] = builtins.builtin_relations_by_name[name]
+            else:
+                name, fields = self._parse_relation_name(name, f.field)
+                fields.extend(
+                    f.field(
+                        arg.display() if not isinstance(arg, Wildcard) else ctx.project_away_var_name(),
+                        self.to_type(role.root_unconstrained_type())
+                    )
+                    for arg, role in zip(item.args, item.relcomp._signature._types)
+                )
+                annotations = [builtins.external_annotation] if isinstance(item.relcomp, AssertedRelation) else []
+                self.relations[entity_id] = f.relation(name, fields, annos=annotations)
+        return self.relations[entity_id]
+
+    def to_args(self, ctx: CompilerContext, item: Atom) -> tuple[list[ir.Value], list[ir.Value]]:
+        args_list = []
+        project_away_vars = []
+
+        for arg, role in zip(item.args, item.relcomp._signature._types):
+            if isinstance(arg, Wildcard):
+                project_away_var = ctx.to_project_away_var(self.to_type(role.root_unconstrained_type()))
+                project_away_vars.append(project_away_var)
+                args_list.append(project_away_var)
+            else:
+                args_list.append(self.to_var(ctx, arg))
+
+        return args_list, project_away_vars
+
+    def to_vars(self, ctx:CompilerContext, item:ExistentialConstraint) -> set[ir.Var]:
+        return {self.to_var(ctx, cur) for cur in item._scalars.values()}
+
+    def to_var(self, ctx:CompilerContext, item:Union[RelVariable, Literal]) -> ir.Var:
+        return ctx.to_var(item, self.to_type(item._type.root_unconstrained_type())) \
+            if isinstance(item, RelVariable) else ctx.to_var(item)
+
+    def compile_head(self, ctx:CompilerContext, head:Atom, original_name:str,
+                     annotations: Optional[PySequence[ir.Annotation]]=None) -> ir.Task:
+        name, sig_vars = self._parse_relation_name(original_name, f.var)
+        sig_vars.extend(self.to_var(ctx, cur) for cur in head.args)
+        return self._compile_output(head, sig_vars) if name == 'output' \
+            else f.derive(self.to_relation(ctx, head, original_name), sig_vars, annotations)
+
+    @staticmethod
+    def _compile_output(item:Atom, sig_vars: List[Union[ir.Field, ir.Var]]):
+        annotations = [builtins.export_annotation, builtins.external_annotation] \
+            if isinstance(item.relcomp, ExportRelation) else []
+        return f.output([(var.name, var) for var in sig_vars], annos=annotations)
+
+    @staticmethod
+    def _compile_annotations(annotations:PySequence[Annotation]) -> Optional[PySequence[ir.Annotation]]:
+        return [f.annotation(f.relation(str(a), []), []) for a in annotations]
+
+    def compile_atom(self, ctx:CompilerContext, atom:Atom) -> Union[ir.Construct, ir.Lookup, ir.Not]:
+        original_name = atom.relcomp.qualified_name()
+        name, args = self._parse_relation_name(original_name, f.var)
+        if name.startswith('^'):
+            vs = tuple(self.to_var(ctx, arg) for arg in atom.args[:-1])
+            return ir.Construct(None, (name[1:], *vs), self.to_var(ctx, atom.args[-1]))
+        else:
+            atom_args, project_away_vars = self.to_args(ctx, atom)
+            args.extend(atom_args)
+            task = f.lookup(self.to_relation(ctx, atom, original_name), args)
+            if len(project_away_vars) > 0:
+                task = f.exists(list(project_away_vars), f.logical([task]))
+            return f.not_(task) if atom.negated else task
+
+    def _compile_scalar_expressions(self, ctx, scalar_constraint):
+        left = scalar_constraint.left
+        right = scalar_constraint.right
+
+        expr = right if isinstance(right, (BinaryScalarExpr, Aggregation)) else left
+        other = left if expr is right else right
+
+        return (
+            self._compile_binary_scalar_expressions(ctx, expr, other)
+            if isinstance(expr, BinaryScalarExpr)
+            else self._compile_aggregation(ctx, expr, other)
+        )
+
+    # Example of a binary scalar expression: ( c = a / b ) or ( a / b = c )
+    def _compile_binary_scalar_expressions(self, ctx, left:BinaryScalarExpr, right:RelVariable):
+        args = [self.to_var(ctx, left._left), self.to_var(ctx, left._right), self.to_var(ctx, right)]
+        return f.lookup(builtins.builtin_relations_by_name[left.op()], args)
+
+    # Example of an aggregation:
+    #   - ( d = sum[(e): l1(c, e) and l2(a, e) ] ) or
+    #   - ( sum[(e): l1(c, e) and l2(a, e) ] = d )
+    # Expected IR:
+    #   Logical
+    #     Lookup l1(c, e)
+    #     Lookup l2(a, e)
+    #     Aggregate sum( [], [a, c], [e, d] )
+    #     Hoist d a c
+    #
+    # We need to handle `count` aggregation differently.
+    #   - ( d = count[(e): l1(e) ] )
+    # Expected IR:
+    #   Logical
+    #     Lookup l1(e)
+    #     Aggregate count( [e], [], [d] )
+    #     Hoist d
+    def _compile_aggregation(self, ctx, left:Aggregation, right:RelVariable) -> ir.Aggregate:
+        method = left._method
+        result_var = self.to_var(ctx, right)
+        vargs = [self.to_var(ctx, var) for var in left._scalars.values()]
+        items, lookup_args = self._compile_atoms_and_scalar_constraints(ctx, left._atoms.values(), left._sconstraints.values())
+        group_vars = lookup_args - vargs
+        agg_relation = builtins.builtin_relations_by_name[method]
+        projection = vargs if self._is_count_aggregation(method) else vargs[:-1]
+        args = [result_var] if self._is_count_aggregation(method) else [vargs[-1], result_var]
+        items.add(f.aggregate(agg_relation, projection, group_vars.list, args))
+        return f.logical(list(items), [result_var, *group_vars.list])
+
+    def compile_scalar_constraint(self, ctx:CompilerContext, scalar_constraint:ScalarConstraint) -> ir.Task:
+        if all(isinstance(side, BinaryScalarExpr) for side in (scalar_constraint.left, scalar_constraint.right)):
+            raise Exception("It's not allowed for left and right operands to be BinaryScalarExpr.")
+        if any(isinstance(side, (BinaryScalarExpr, Aggregation)) for side in (scalar_constraint.right, scalar_constraint.left)):
+            return self._compile_scalar_expressions(ctx, scalar_constraint)
+        else:
+            args = [self.to_var(ctx, scalar_constraint.left), self.to_var(ctx, scalar_constraint.right)]
+            return f.lookup(builtins.builtin_relations_by_name[scalar_constraint.op], args)
+
+    # TODO: Replace to this one when we implement this in the to Rel Emitter
+    # def compile_existential(self, ctx:CompilerContext, existential:ExistentialConstraint) -> ir.Task:
+    #     items, vargs = (self._compile_atoms_and_scalar_constraints(ctx, existential._atoms.values(), existential._sconstraints.values()))
+    #     return f.logical(list(items), (vargs - self.to_vars(ctx, existential)).list)
+
+    def compile_existential(self, ctx:CompilerContext, existential:ExistentialConstraint) -> ir.Task:
+        items = ordered_set()
+        for atom in existential._atoms.values():
+            items.add(self.compile_atom(ctx, atom))
+        for scalar_constraint in existential._sconstraints.values():
+            items.add(self.compile_scalar_constraint(ctx, scalar_constraint))
+        return f.exists(list(self.to_vars(ctx, existential)), f.logical(list(items)))
+
+    def _compile_atoms_and_scalar_constraints(self, ctx: CompilerContext, atoms: [Atom], scalar_constraints: [ScalarConstraint]) \
+            -> Tuple[OrderedSet[ir.Task], OrderedSet[ir.Var]]:
+        items = ordered_set()
+        vargs = ordered_set()
+        for atom in atoms:
+            comp_atom = self.compile_atom(ctx, atom)
+            if not isinstance(comp_atom, ir.Construct):
+                vargs.update(arg for arg in comp_atom.args if self._arg_filter(arg))
+            items.add(comp_atom)
+        for scalar_constraint in scalar_constraints:
+            comp_scalar = self.compile_scalar_constraint(ctx, scalar_constraint)
+            if isinstance(comp_scalar, ir.Lookup):
+                vargs.update(arg for arg in comp_scalar.args if self._arg_filter(arg))
+            elif isinstance(comp_scalar, ir.Logical):
+                vargs.update(comp_scalar.hoisted)
+            items.add(comp_scalar)
+        return items, vargs
+
+    @staticmethod
+    def _arg_filter(arg):
+        return not isinstance(arg, ir.Literal) and not arg.name.startswith(":")
+
+    @staticmethod
+    def _is_count_aggregation(method: str) -> bool:
+        return method == "count"
+
+    def compile_rule(self, rule:Rule, name:str) -> ir.Task:
+        ctx = CompilerContext()
+        for existential in rule._existentials.values():
+            if len(existential._scalars) != 0:
+                ctx.add(self.compile_existential(ctx, existential))
+            else:
+                for atom in existential._atoms.values():
+                    ctx.add(self.compile_atom(ctx, atom))
+                for scalar_constraint in existential._sconstraints.values():
+                    ctx.add(self.compile_scalar_constraint(ctx, scalar_constraint))
+        for atom in rule._atoms.values():
+            ctx.add(self.compile_atom(ctx, atom))
+        for scalar_constraint in rule._sconstraints.values():
+            ctx.add(self.compile_scalar_constraint(ctx, scalar_constraint))
+        ctx.add(self.compile_head(ctx, rule.head, name, self._compile_annotations(rule._annotations)))
+        return f.logical(list(ctx.items))
+
+    def compile_raw_sources(self, raw_sources: OrderedSet[RawSource]) -> ir.Model:
+        return f.compute_model(
+            f.logical([
+                f.logical([f.derive(builtins.raw_source, [rs.language, rs.raw_source])])
+                for rs in raw_sources
+            ])
+        )
+
+    def compile_model(self, model: Model) -> ir.Model:
+        return f.compute_model(
+            f.logical(
+                [self.compile_rule(rule, relation.qualified_name())
+                 for relation in model._relations.values()
+                 for rule in relation._rules]
+            )
+        )
+
+    def compile_queries(self, queries: OrderedSet[Relation]) -> ir.Model:
+        return f.compute_model(
+            f.logical([
+                self.compile_rule(rule, query.qualified_name())
+                for query in queries
+                for rule in query._rules
+            ])
+        )
+
+    def compile_export(self, export: Export) -> ir.Model:
+        return f.compute_model(
+            f.logical([
+                self.compile_rule(rule, column.qualified_name())
+                for column in export.columns
+                for rule in column._rules
+            ])
+        )