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

relationalai/semantics/lqp/types.py

@@ -1,101 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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/compiler.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass, field
-from typing import Any, Optional, Iterable, Sequence as PySequence, Union
-
-from relationalai import debugging
-from relationalai.semantics.metamodel import ir, visitor
-from relationalai.semantics.metamodel.util import OrderedSet, ordered_set, group_by
-
-
-
-@dataclass(frozen=True)
-class Compiler():
-    """ Compilers can rewrite a model into a different model, and can compile a model into
-    a String, usually of a different language like Rel or SQL. """
-    # configurable sequence of passes
-    passes: list[Pass]
-
-    def rewrite(self, model: ir.Model, options:dict={}) -> ir.Model:
-        """ Apply a sequence of transformation passes over a model, creating a new model. """
-        with debugging.span("passes") as span:
-            for p in self.passes:
-                with debugging.span(p.name) as span:
-                    model = p.rewrite(model, options)
-                    span["metamodel"] = str(model.root)
-                p.reset()
-        return model
-
-    def compile(self, model: ir.Model, options:dict={}) -> Any:
-        return self.compile_inner(model, options)[0]
-
-    def compile_inner(self, model: ir.Model, options:dict={}) -> tuple[Any, ir.Model]:
-        model = self.rewrite(model, options)
-        return self.do_compile(model, options), model
-
-    def do_compile(self, model: ir.Model, options:dict={}) -> Any:
-        """ Perform the compilation from model to string. The default implementation simply
-        pretty prints the model IR. """
-        return ir.node_to_string(model)
-
-
-@dataclass
-class Pass():
-    """
-    A compiler rewrite pass.
-    """
-    @property
-    def name(self):
-        return self.__class__.__name__
-
-    def rewrite(self, model: ir.Model, options:dict={}) -> ir.Model:
-        raise NotImplementedError(f"{self.name} rewrite not implemented")
-
-    def reset(self):
-        pass
-
-# TODO - maybe extract these into a compiler_utils module?
-
-def group_tasks(tasks: PySequence[ir.Task], categories: dict[str, Union[type, tuple[type, ...]]]) -> dict[str, OrderedSet[ir.Task]]:
-    """ Categorize these tasks in these categories, based on their types. The categories
-    dict contains a category name to the set of types that should be in this category. The
-    result is a dict from that name to the Tasks in that category. There is a special
-    "other" category for uncategorized tasks. """
-    def categorize(n):
-        for category, types in categories.items():
-            if isinstance(n, types):
-                return category
-        return "other"
-
-    groups = group_by(tasks, lambda t: categorize(t))
-    # ensure all categories have an entry
-    for key in categories:
-        if key not in groups:
-            groups[key] = ordered_set()
-    if "other" not in groups:
-            groups["other"] = ordered_set()
-    return groups
-
-
-@dataclass(frozen=True)
-class VarMap:
-    """ Maintain a map from variables in the original metamodel to the corresponding
-    variables in the rewritten metamodel. """
-    mapping: dict[ir.Var, ir.Var] = field(default_factory=dict)
-
-    def get(self, v: ir.Var) -> ir.Var:
-        if v not in self.mapping:
-            self.mapping[v] = ir.Var(v.type, v.name)
-        return self.mapping[v]
-
-    def get_many(self, vars: Iterable[ir.Var]) -> list[ir.Var]:
-        return [self.get(v) for v in vars]
-
-    def __contains__(self, var: ir.Var):
-        return var in self.mapping
-
-
-@dataclass
-class ReplaceVars(visitor.Rewriter):
-    """ A pass that replaces variables found with the mapping from the VarMap. """
-    varmap: VarMap = field(init=True)
-
-    def handle_var(self, node: ir.Var, parent: ir.Node, ctx:Optional[Any]=None):
-        if node in self.varmap:
-            return self.varmap.get(node)
-        return node
-
-@dataclass
-class DumpModel(Pass):
-    """ A pass that dumps the model, verbosely. """
-    header: str = field(init=True, default="")
-
-    def rewrite(self, model: ir.Model, options:dict={}) -> ir.Model:
-        if self.header:
-            print("-" * 80)
-            print(self.header)
-            print()
-        ir.dump(model)
-        print()
-        return model
-
-@dataclass
-class PrintModel(Pass):
-    """ A pass that prints the model. """
-    header: str = field(init=True, default="")
-
-    def rewrite(self, model: ir.Model, options:dict={}) -> ir.Model:
-        if self.header:
-            print("-" * 80)
-            print(self.header)
-            print()
-        print(model)
-        print()
-        return model