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

relationalai/semantics/lqp/types.py

@@ -0,0 +1,101 @@
+from relationalai.semantics.metamodel import ir as meta
+from relationalai.semantics.metamodel import types
+from relationalai.semantics.lqp import ir as lqp
+from relationalai.semantics.lqp.constructors import mk_type, mk_value
+from typing import Union
+
+# LQP Integer type limits
+INT_MIN = -2**63 # LQP INT is a 64-bit signed integer
+INT_MAX = 2**63 - 1 # LQP INT is a 64-bit signed integer
+INT128_MIN = -2**127
+INT128_MAX = 2**127 - 1
+UINT128_MIN = 0
+UINT128_MAX = 2**128 - 1
+
+PrimitiveValue = Union[
+    str, int, float, lqp.UInt128Value, lqp.Int128Value, lqp.DecimalValue, lqp.DateValue,
+    lqp.DateTimeValue, lqp.BooleanValue
+]
+
+def is_numeric(type: lqp.Type) -> bool:
+    # UInt128 is used for hash, RowID, and entity ids so we don't include it as numeric
+    return type.type_name in {
+        lqp.TypeName.INT, lqp.TypeName.INT128, lqp.TypeName.FLOAT, lqp.TypeName.DECIMAL
+    }
+
+def meta_type_to_lqp(typ: meta.Type) -> lqp.Type:
+    if isinstance(typ, meta.UnionType):
+        # By this point, unions can only consist of entity types. In the LQP,
+        # they are undifferentiated (hashes), so they all merge.
+        assert all(types.is_entity_type(t) for t in typ.types), \
+            f"Union type {typ} contains non-entity types: " \
+            f"{[t for t in typ.types if not types.is_entity_type(t)]}"
+
+        return mk_type(lqp.TypeName.UINT128)
+    else:
+        assert isinstance(typ, meta.ScalarType)
+        if isinstance(typ, meta.DecimalType):
+            # deal first with decimals as they may be in the builtin set as well
+            return mk_type(lqp.TypeName.DECIMAL, [mk_value(typ.precision), mk_value(typ.scale)])
+        elif types.is_builtin(typ):
+            if typ == types.Int64:
+                return mk_type(lqp.TypeName.INT)
+            elif typ == types.Int128:
+                return mk_type(lqp.TypeName.INT128)
+            elif typ == types.Float:
+                return mk_type(lqp.TypeName.FLOAT)
+            elif typ == types.String:
+                return mk_type(lqp.TypeName.STRING)
+            elif typ == types.Date:
+                return mk_type(lqp.TypeName.DATE)
+            elif typ == types.DateTime:
+                return mk_type(lqp.TypeName.DATETIME)
+            elif typ == types.Hash:
+                return mk_type(lqp.TypeName.UINT128)
+            elif typ == types.RowId:
+                return mk_type(lqp.TypeName.UINT128)
+            elif typ == types.UInt128:
+                return mk_type(lqp.TypeName.UINT128)
+            elif typ == types.Bool:
+                return mk_type(lqp.TypeName.BOOLEAN)
+            elif typ == types.Number:
+                # All types must be specified in the LQP.
+                raise Exception("Number type could not be determined.")
+            elif types.is_any(typ):
+                # All types must be specified in the LQP.
+                raise Exception("Type could not be determined.")
+            else:
+                raise NotImplementedError(f"Unknown builtin type: {typ.name}")
+        elif types.is_entity_type(typ):
+            return mk_type(lqp.TypeName.UINT128)
+        else:
+            # Otherwise, the type extends some other type, we use that instead
+            assert len(typ.super_types) > 0, f"Type {typ} has no super types"
+            assert len(typ.super_types) == 1, f"Type {typ} has multiple super types: {typ.super_types}"
+            super_type = typ.super_types[0]
+            assert isinstance(super_type, meta.ScalarType), f"Super type {super_type} of {typ} is not a scalar type"
+            return meta_type_to_lqp(super_type)
+
+def lqp_type_to_sql(arg: lqp.Type) -> str:
+    if arg.type_name == lqp.TypeName.INT:
+        return "NUMBER(38, 0)"
+    elif arg.type_name == lqp.TypeName.FLOAT:
+        return "FLOAT"
+    elif arg.type_name == lqp.TypeName.STRING:
+        return "VARCHAR"
+    elif arg.type_name == lqp.TypeName.INT128:
+        return "NUMBER(38, 0)"
+    elif arg.type_name == lqp.TypeName.UINT128:
+        return "NUMBER(38, 0)"
+    elif arg.type_name == lqp.TypeName.DATE:
+        return "DATE"
+    elif arg.type_name == lqp.TypeName.DATETIME:
+        return "DATETIME"
+    elif arg.type_name == lqp.TypeName.DECIMAL:
+        assert len(arg.parameters) == 2, \
+            f"DECIMAL type must have 2 parameters, got {arg.parameters}"
+        precision = arg.parameters[0].value
+        scale = arg.parameters[1].value
+        return f"NUMBER({precision}, {scale})"
+    else:
+        raise NotImplementedError(f"Unknown relational value type: {arg}")

relationalai/semantics/lqp/utils.py

@@ -0,0 +1,160 @@
+from relationalai.semantics.lqp import ir as lqp
+from relationalai.semantics.metamodel import ir
+from relationalai.semantics.metamodel.helpers import sanitize
+from relationalai.semantics.metamodel.util import FrozenOrderedSet
+
+from hashlib import sha256
+from typing import Tuple
+
+class UniqueNames:
+    def __init__(self):
+        # Track count of seen names
+        self.seen = dict[str, int]()
+        # Maps id to unique name
+        self.id_to_name = dict[int,str]()
+
+    def get_name(self, name: str) -> str:
+        # Names will eventually be sanitized, which could cause collisions, so we
+        # do the sanitization here.
+        name = '_' if name == '_' else sanitize(name)
+        if name not in self.seen:
+            self.seen[name] = 1
+            return f"{name}"
+
+        self.seen[name] += 1
+        id = self.seen[name]
+        # If the original name has a suffix we can get collisions with generated names,
+        # so test the new name.
+        while f"{name}_{id}" in self.seen:
+            id += 1
+            self.seen[name] = id
+        new_name = f"{name}_{id}"
+        self.seen[new_name] = 1
+        return new_name
+
+    # Get a unique name for the given id. If the id is already in the map, return the
+    # existing name. Otherwise, generate a new name using the suggested_name and
+    # store it in the map.
+    def get_name_by_id(self, id: int, suggested_name:str) -> str:
+        if id in self.id_to_name:
+            return self.id_to_name[id]
+
+        name = self.get_name(suggested_name)
+        self.id_to_name[id] = name
+        return name
+
+class TranslationCtx:
+    def __init__(self, def_names: UniqueNames = UniqueNames()):
+        # TODO: comment these fields
+        self.def_names = def_names
+        self.var_names = UniqueNames()
+        self.output_names = UniqueNames()
+        # Map relation IDs to their original names for debugging and pretty printing.
+        self.rel_id_to_orig_name = {}
+        self.output_ids: list[tuple[lqp.RelationId, str]] = []
+        self.export_ids: list[tuple[lqp.RelationId, int, lqp.Type]] = []
+
+def gen_rel_id(ctx: TranslationCtx, orig_name: str, suffix: str = "") -> lqp.RelationId:
+    relation_id = lqp.RelationId(id=lqp_hash(orig_name + suffix), meta=None)
+    ctx.rel_id_to_orig_name[relation_id] = orig_name
+    return relation_id
+
+def gen_unique_var(ctx: TranslationCtx, name_hint: str) -> lqp.Var:
+    """
+    Generate a new variable with a unique name based on the provided hint.
+    """
+    name = ctx.var_names.get_name(name_hint)
+    return lqp.Var(name=name, meta=None)
+
+def is_constant(arg, expected_type):
+    """
+    Check if the argument is a constant of the expected type.
+    """
+    if isinstance(arg, ir.Literal):
+        return is_constant(arg.value, expected_type)
+
+    return isinstance(arg, expected_type)
+
+def rename_vars_var(var: lqp.Var, var_map: dict[str, lqp.Var]) -> lqp.Var:
+    return var_map.get(var.name, var)
+
+def rename_vars_relterm(term: lqp.RelTerm, var_map: dict[str, lqp.Var]) -> lqp.RelTerm:
+    if isinstance(term, lqp.Var):
+        return rename_vars_var(term, var_map)
+    else:
+        return term  # Constants do not change
+
+def rename_vars_term(term: lqp.Term, var_map: dict[str, lqp.Var]) -> lqp.Term:
+    if isinstance(term, lqp.Var):
+        return rename_vars_var(term, var_map)
+    else:
+        return term  # Constants do not change
+
+def rename_vars_abstraction(abstraction: lqp.Abstraction, var_map: dict[str, lqp.Var]) -> lqp.Abstraction:
+    new_vars = [(var_map.get(var.name, var), typ) for (var, typ) in abstraction.vars]
+    new_value = rename_vars_formula(abstraction.value, var_map)
+    return lqp.Abstraction(vars=new_vars, value=new_value, meta=abstraction.meta)
+
+def rename_vars_formula(formula: lqp.Formula, var_map: dict[str, lqp.Var]) -> lqp.Formula:
+    if isinstance(formula, lqp.Primitive):
+        return lqp.Primitive(
+            name=formula.name,
+            terms=[rename_vars_relterm(term, var_map) for term in formula.terms],
+            meta=formula.meta
+        )
+    elif isinstance(formula, lqp.Atom):
+        return lqp.Atom(
+            name=formula.name,
+            terms=[rename_vars_term(term, var_map) for term in formula.terms],
+            meta=formula.meta
+        )
+    elif isinstance(formula, lqp.RelAtom):
+        return lqp.RelAtom(
+            name=formula.name,
+            terms=[rename_vars_relterm(term, var_map) for term in formula.terms],
+            meta=formula.meta
+        )
+    elif isinstance(formula, lqp.Not):
+        return lqp.Not(arg=rename_vars_formula(formula.arg, var_map), meta=formula.meta)
+    elif isinstance(formula, lqp.Exists):
+        return lqp.Exists(body=rename_vars_abstraction(formula.body, var_map), meta=None)
+    elif isinstance(formula, lqp.Reduce):
+        return lqp.Reduce(
+            op=formula.op,
+            body=rename_vars_abstraction(formula.body, var_map),
+            terms=[rename_vars_term(term, var_map) for term in formula.terms],
+            meta=formula.meta
+        )
+    elif isinstance(formula, lqp.FFI):
+        return lqp.FFI(
+            meta=formula.meta,
+            name=formula.name,
+            args=[rename_vars_abstraction(arg, var_map) for arg in formula.args],
+            terms=[rename_vars_term(term, var_map) for term in formula.terms]
+        )
+    elif isinstance(formula, lqp.Conjunction):
+        return lqp.Conjunction(
+            args=[rename_vars_formula(arg, var_map) for arg in formula.args],
+            meta=formula.meta
+        )
+    elif isinstance(formula, lqp.Disjunction):
+        return lqp.Disjunction(
+            args=[rename_vars_formula(arg, var_map) for arg in formula.args],
+            meta=formula.meta
+        )
+    elif isinstance(formula, lqp.Cast):
+        return lqp.Cast(
+            input=rename_vars_term(formula.input, var_map),
+            result=rename_vars_term(formula.result, var_map),
+            meta=formula.meta,
+        )
+    else:
+        raise NotImplementedError(f"Unknown formula type: {type(formula)}")
+
+def lqp_hash(node: str) -> int:
+    h = int.from_bytes(sha256(node.encode()).digest(), byteorder='big', signed=False)
+    # Ensure it's within the 128-bit range
+    return h % (2**128)
+
+def output_names(aliases: FrozenOrderedSet[Tuple[str, ir.Value]]) -> list[str]:
+    return [v[0] for v in aliases]

relationalai/semantics/lqp/validators.py

@@ -0,0 +1,57 @@
+from relationalai.semantics.metamodel import ir
+from typing import Union
+
+CompilableType = Union[
+    # Subgrouping
+    ir.Logical,
+    ir.Union,
+
+    # Formulas
+    ir.Lookup,
+    ir.Exists,
+    ir.Construct,
+    ir.Not,
+
+    # Aggregations
+    ir.Aggregate,
+
+    # Rank
+    ir.Rank,
+
+    # Effects
+    ir.Output,
+    ir.Update,
+
+    # Constraints
+    ir.Require,
+]
+
+# Preconditions
+def assert_valid_input(model: ir.Model) -> None:
+    task = model.root
+
+    assert isinstance(task, ir.Logical), f"expected root to be logical task, got {type(task)}"
+    for subtask in task.body:
+        _assert_valid_subtask(subtask)
+
+def _assert_valid_subtask(task: ir.Task) -> None:
+    # TODO: assert what subtasks should look like
+    assert isinstance(task, ir.Logical), f"expected logical task, got {type(task)}"
+    _assert_task_compilable(task)
+
+def _assert_task_compilable(task: ir.Task) -> None:
+    assert isinstance(task, CompilableType), f"expected task to be compilable, got {type(task)}"
+    if isinstance(task, ir.Logical):
+        for subtask in task.body:
+            _assert_task_compilable(subtask)
+    elif isinstance(task, ir.Union):
+        for subtask in task.tasks:
+            _assert_task_compilable(subtask)
+    elif isinstance(task, ir.Update):
+        assert_valid_update(task)
+        effect = task.effect
+        assert effect == ir.Effect.derive, "only derive supported at the moment"
+
+def assert_valid_update(update: ir.Update) -> None:
+    effect = update.effect
+    assert effect == ir.Effect.derive, "only derive supported at the moment"

relationalai/semantics/metamodel/__init__.py

@@ -1,6 +1,40 @@
-from .metamodel import (
-    Node, Capability, Reasoner, Field, Reading, Overload, Relation, Annotation,
-    TypeNode, ScalarType, NumberType, UnionType, ListType, Type, Primitive, Table,
-    Var, Literal, Value, Task, Logical, Sequence, Union, Match, Until, Wait, Loop, Break,
-    Require, Not, Exists, Effect, Lookup, Update, Aggregate, Construct, Data, Model
-)
+from .ir import Node, Model, Capability, Engine
+from .ir import Type, ScalarType, ListType, UnionType, Field, Relation
+from .ir import Task, Logical, Union, Sequence, Match, Until, Wait
+from .ir import Not, Exists, ForAll, Loop, Break
+from .ir import Var, Literal, Value, Annotation, Effect, Update, Lookup, Output, Construct, Aggregate
+
+__all__ = [
+    "Node",
+    "Model",
+    "Capability",
+    "Engine",
+    "Type",
+    "ScalarType",
+    "ListType",
+    "UnionType",
+    "Field",
+    "Relation",
+    "Task",
+    "Logical",
+    "Union",
+    "Sequence",
+    "Match",
+    "Until",
+    "Wait",
+    "Not",
+    "Exists",
+    "ForAll",
+    "Loop",
+    "Break",
+    "Var",
+    "Literal",
+    "Value",
+    "Annotation",
+    "Effect",
+    "Update",
+    "Lookup",
+    "Output",
+    "Construct",
+    "Aggregate"
+]