relationalai 0.11.2__py3-none-any.whl → 0.11.4__py3-none-any.whl

relationalai/semantics/metamodel/builtins.py

@@ -88,12 +88,36 @@ abs = f.relation(
 
 natural_log = f.relation(
     "natural_log",
-    [f.input_field("a", types.Number), f.field("b", types.Number)],
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
     overloads=[
         f.relation("natural_log", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
         f.relation("natural_log", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
         f.relation("natural_log", [f.input_field("a", types.Float), f.field("b", types.Float)]),
-        f.relation("natural_log", [f.input_field("a", types.GenericDecimal), f.field("b", types.GenericDecimal)]),
+        f.relation("natural_log", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)]),
+
+    ],
+)
+
+log10 = f.relation(
+    "log10",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("log10", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("log10", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("log10", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("log10", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)]),
+
+    ],
+)
+
+log = f.relation(
+    "log",
+    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Float)],
+    overloads=[
+        f.relation("log", [f.input_field("a", types.Int64), f.input_field("b", types.Int64), f.field("c", types.Float)]),
+        f.relation("log", [f.input_field("a", types.Int128), f.input_field("b", types.Int128), f.field("c", types.Float)]),
+        f.relation("log", [f.input_field("a", types.Float), f.input_field("b", types.Float), f.field("c", types.Float)]),
+        f.relation("log", [f.input_field("a", types.GenericDecimal), f.input_field("b", types.GenericDecimal), f.field("c", types.Float)]),
 
     ],
 )
@@ -274,9 +298,100 @@ asinh = f.relation(
     ],
 )
 
+tan = f.relation(
+    "tan",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("tan", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("tan", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("tan", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("tan", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+tanh = f.relation(
+    "tanh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("tanh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("tanh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("tanh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("tanh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+atan = f.relation(
+    "atan",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("atan", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("atan", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("atan", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("atan", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+atanh = f.relation(
+    "atanh",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("atanh", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("atanh", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("atanh", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("atanh", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+cot = f.relation(
+    "cot",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    # Everything will be converted to float to avoid NaN results with other types
+    overloads=[
+        f.relation("cot", [f.input_field("a", types.Float), f.field("b", types.Float)])
+    ],
+)
+
+acot = f.relation(
+    "acot",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    # Everything will be converted to float to avoid NaN results with other types
+    overloads=[
+        f.relation("acot", [f.input_field("a", types.Float), f.field("b", types.Float)])
+    ],
+)
+
+exp = f.relation(
+    "exp",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        f.relation("exp", [f.input_field("a", types.Int64), f.field("b", types.Float)]),
+        f.relation("exp", [f.input_field("a", types.Int128), f.field("b", types.Float)]),
+        f.relation("exp", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+        f.relation("exp", [f.input_field("a", types.GenericDecimal), f.field("b", types.Float)])
+    ],
+)
+
+erf = f.relation(
+    "erf",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        # Everything will be converted to float to avoid NaN results with other types
+        f.relation("erf", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+    ],
+)
+
+erfinv = f.relation(
+    "erfinv",
+    [f.input_field("a", types.Number), f.field("b", types.Float)],
+    overloads=[
+        # Everything will be converted to float to avoid NaN results with other types
+        f.relation("erfinv", [f.input_field("a", types.Float), f.field("b", types.Float)]),
+    ],
+)
+
+
 # Strings
 concat = f.relation("concat", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.String)])
-num_chars = f.relation("num_chars", [f.input_field("a", types.String), f.field("b", types.Int128)])
+num_chars = f.relation("num_chars", [f.input_field("a", types.String), f.field("b", types.Int64)])
 starts_with = f.relation("starts_with", [f.input_field("a", types.String), f.input_field("b", types.String)])
 ends_with = f.relation("ends_with", [f.input_field("a", types.String), f.input_field("b", types.String)])
 contains = f.relation("contains", [f.input_field("a", types.String), f.input_field("b", types.String)])
@@ -291,22 +406,41 @@ replace = f.relation("replace", [f.input_field("a", types.String), f.input_field
 split = f.relation("split", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Int64), f.field("d", types.String)])
 # should be a separate builtin. SQL emitter compiles it differently
 split_part = f.relation("split_part", [f.input_field("a", types.String), f.input_field("b", types.String), f.field("c", types.Int64), f.field("d", types.String)])
+
+# regex
 regex_match = f.relation("regex_match", [f.input_field("a", types.String), f.input_field("b", types.String)])
+regex_match_all = f.relation("regex_match_all", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64),  f.field("d", types.String)])
+capture_group_by_index = f.relation("capture_group_by_index", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64), f.input_field("d", types.Int64), f.field("e", types.String)])
+capture_group_by_name = f.relation("capture_group_by_name", [f.input_field("a", types.String), f.input_field("b", types.String), f.input_field("c", types.Int64), f.input_field("d", types.String), f.field("e", types.String)])
+escape_regex_metachars = f.relation("escape_regex_metachars", [f.input_field("a", types.String), f.field("b", types.String)])
 
 # Dates
 date_format = f.relation("date_format", [f.input_field("a", types.Date), f.input_field("b", types.String), f.field("c", types.String)])
 datetime_format = f.relation("datetime_format", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.input_field("c", types.String), f.field("d", types.String)])
 date_year = f.relation("date_year", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_quarter = f.relation("date_quarter", [f.input_field("a", types.Date), f.field("b", types.Int64)])
 date_month = f.relation("date_month", [f.input_field("a", types.Date), f.field("b", types.Int64)])
 date_week = f.relation("date_week", [f.input_field("a", types.Date), f.field("b", types.Int64)])
 date_day = f.relation("date_day", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_dayofyear = f.relation("date_dayofyear", [f.input_field("a", types.Date), f.field("b", types.Int64)])
+date_weekday = f.relation("date_weekday", [f.input_field("a", types.Date), f.field("b", types.Int64)])
 date_add = f.relation("date_add", [f.input_field("a", types.Date), f.input_field("b", types.Int64), f.field("c", types.Date)])
 dates_period_days = f.relation("dates_period_days", [f.input_field("a", types.Date), f.input_field("b", types.Date), f.field("c", types.Int64)])
 datetimes_period_milliseconds = f.relation("datetimes_period_milliseconds", [f.input_field("a", types.DateTime), f.input_field("b", types.DateTime), f.field("c", types.Int64)])
 date_subtract = f.relation("date_subtract", [f.input_field("a", types.Date), f.input_field("b", types.Int64), f.field("c", types.Date)])
+datetime_now = f.relation("datetime_now", [f.field("a", types.DateTime)])
 datetime_add = f.relation("datetime_add", [f.input_field("a", types.DateTime), f.input_field("b", types.Int64), f.field("c", types.DateTime)])
 datetime_subtract = f.relation("datetime_subtract", [f.input_field("a", types.DateTime), f.input_field("b", types.Int64), f.field("c", types.DateTime)])
+datetime_year = f.relation("datetime_year", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_quarter = f.relation("datetime_quarter", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_month = f.relation("datetime_month", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
 datetime_week = f.relation("datetime_week", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_day = f.relation("datetime_day", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_dayofyear = f.relation("datetime_dayofyear", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_hour = f.relation("datetime_hour", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_minute = f.relation("datetime_minute", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
+datetime_second = f.relation("datetime_second", [f.input_field("a", types.DateTime), f.field("c", types.Int64)])
+datetime_weekday = f.relation("datetime_weekday", [f.input_field("a", types.DateTime), f.input_field("b", types.String), f.field("c", types.Int64)])
 
 # Other
 range = f.relation("range", [
@@ -319,6 +453,7 @@ range = f.relation("range", [
 hash = f.relation("hash", [f.input_field("args", types.AnyList), f.field("hash", types.Hash)])
 
 uuid_to_string = f.relation("uuid_to_string", [f.input_field("a", types.Hash), f.field("b", types.String)])
+parse_uuid = f.relation("parse_uuid", [f.input_field("a", types.String), f.field("b", types.Hash)])
 
 # Raw source code to be attached to the transaction, when the backend understands this language
 raw_source = f.relation("raw_source", [f.input_field("lang", types.String), f.input_field("source", types.String)])
@@ -462,6 +597,8 @@ parse_int64 = f.relation("parse_int64", [f.input_field("a", types.String), f.fie
 parse_int128 = f.relation("parse_int128", [f.input_field("a", types.String), f.field("b", types.Int128)])
 parse_float = f.relation("parse_float", [f.input_field("a", types.String), f.field("b", types.Float)])
 
+nanosecond = f.relation("nanosecond", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
+microsecond = f.relation("microsecond", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
 millisecond = f.relation("millisecond", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
 second = f.relation("second", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
 minute = f.relation("minute", [f.input_field("a", types.Int64), f.field("b", types.Int64)])
@@ -484,7 +621,6 @@ cast = f.relation(
 # Date construction with less overhead
 construct_date = f.relation("construct_date", [f.input_field("year", types.Int64), f.input_field("month", types.Int64), f.input_field("day", types.Int64), f.field("date", types.Date)])
 construct_date_from_datetime = f.relation("construct_date_from_datetime", [f.input_field("datetime", types.DateTime), f.input_field("timezone", types.String), f.field("date", types.Date)])
-construct_datetime = f.relation("construct_datetime", [f.input_field("year", types.Int64), f.input_field("month", types.Int64), f.input_field("day", types.Int64), f.input_field("hour", types.Int64), f.input_field("minute", types.Int64), f.input_field("second", types.Int64), f.field("datetime", types.DateTime)])
 construct_datetime_ms_tz = f.relation("construct_datetime_ms_tz", [f.input_field("year", types.Int64), f.input_field("month", types.Int64), f.input_field("day", types.Int64), f.input_field("hour", types.Int64), f.input_field("minute", types.Int64), f.input_field("second", types.Int64), f.input_field("milliseconds", types.Int64), f.input_field("timezone", types.String), f.field("datetime", types.DateTime)])
 
 # Solver helpers
@@ -545,18 +681,23 @@ builtin_relations_by_name = dict((r.name, r) for r in builtin_relations)
 
 string_binary_builtins = [num_chars, starts_with, ends_with, contains, like_match, lower, upper, strip, regex_match]
 
-date_builtins = [date_year, date_month, date_week, date_day, date_add, date_subtract, dates_period_days,
-                 datetime_add, datetime_subtract, datetimes_period_milliseconds, datetime_week]
+date_builtins = [date_year, date_quarter, date_month, date_week, date_day, date_dayofyear, date_add, date_subtract,
+                 dates_period_days, datetime_add, datetime_subtract, datetimes_period_milliseconds, datetime_year,
+                 datetime_quarter, datetime_month, datetime_week, datetime_day, datetime_dayofyear, datetime_hour,
+                 datetime_minute, datetime_second, date_weekday, datetime_weekday]
 
-date_periods = [year, month, week, day, hour, minute, second, millisecond]
+date_periods = [year, month, week, day, hour, minute, second, millisecond, microsecond, nanosecond]
 
-math_unary_builtins = [abs, *abs.overloads, natural_log, *natural_log.overloads, sqrt, *sqrt.overloads,
+math_unary_builtins = [abs, *abs.overloads, sqrt, *sqrt.overloads,
+                       natural_log, *natural_log.overloads, log10, *log10.overloads,
                        cbrt, *cbrt.overloads, factorial, *factorial.overloads, cos, *cos.overloads,
                        cosh, *cosh.overloads, acos, *acos.overloads, acosh, *acosh.overloads, sin, *sin.overloads,
-                       sinh, *sinh.overloads, asin, *asin.overloads, asinh, *asinh.overloads, ceil, *ceil.overloads,
-                       floor, *floor.overloads]
+                       sinh, *sinh.overloads, asin, *asin.overloads, asinh, *asinh.overloads, tan, *tan.overloads,
+                       tanh, *tanh.overloads, atan, *atan.overloads, atanh, *atanh.overloads, *ceil.overloads,
+                       cot, *cot.overloads, acot, *acot.overloads, floor, *floor.overloads, exp, *exp.overloads,
+                       erf, *erf.overloads, erfinv, *erfinv.overloads]
 
 math_builtins = [*math_unary_builtins, maximum, *maximum.overloads, minimum, *minimum.overloads, mod, *mod.overloads,
-                 pow, *pow.overloads, power, *power.overloads, trunc_div, *trunc_div.overloads]
+                 pow, *pow.overloads, power, *power.overloads, log, *log.overloads, trunc_div, *trunc_div.overloads]
 
 pragma_builtins = [rule_reasoner_sem_vo, rule_reasoner_phys_vo]

relationalai/semantics/metamodel/factory.py

@@ -185,10 +185,11 @@ def lit(value: Any) -> ir.Value:
         return ir.Literal(types.Bool, value)
     elif isinstance(value, decimal.Decimal):
         return ir.Literal(types.Decimal, value)
-    elif isinstance(value, datetime.date):
-        return ir.Literal(types.Date, value)
+    # datetime.datetime is a subclass of datetime.date, so check it first
     elif isinstance(value, datetime.datetime):
         return ir.Literal(types.DateTime, value)
+    elif isinstance(value, datetime.date):
+        return ir.Literal(types.Date, value)
     elif isinstance(value, list):
         return tuple([lit(v) for v in value])
     else:

relationalai/semantics/metamodel/helpers.py

@@ -4,7 +4,8 @@ Helpers to analyze the metamodel IR.
 from __future__ import annotations
 
 import re
-from typing import cast, Tuple, Iterable, Optional
+from dataclasses import fields
+from typing import cast, Tuple, Iterable, Optional, TypeVar
 from relationalai.semantics.metamodel import ir, visitor, builtins, types, factory as f
 from relationalai.semantics.metamodel.util import NameCache, OrderedSet, FrozenOrderedSet, flatten_tuple, ordered_set
 
@@ -263,7 +264,7 @@ def extract(task: ir.Task, body: OrderedSet[ir.Task], exposed_vars: list[ir.Var]
     body.add(f.derive(connection, exposed_vars))
 
     # extract the body
-    ctx.top_level.append(ir.Logical(task.engine, tuple(), tuple(body)))
+    ctx.top_level.append(clone_task(ir.Logical(task.engine, tuple(), tuple(body))))
 
     return connection
 
@@ -282,3 +283,78 @@ def create_task_name(name_cache: NameCache, task: ir.Task, prefix: Optional[str]
     """ Helper to generate consistent names for tasks extracted from a logical. """
     prefix = prefix if prefix else f"_{task.kind}"
     return name_cache.get_name(task.id, prefix)
+
+
+CLONABLE = (ir.Var, ir.Default, ir.Task)
+T = TypeVar('T', bound=ir.Task)
+def clone_task(task: T) -> T:
+    """
+    Create a new task that is a clone of this task. This operation clones only sub-tasks
+    and variables, and preserves variable references.
+
+    This is useful when we are rewriting the metamodel and want to copy parts of a task to
+    some other place. It is important to clone to avoid having the same object present
+    multiple times in the metamodel.
+    """
+
+    # map from original object id to the rewritten object
+    cache = {}
+    def from_cache(original):
+        """ Lookup this object from the cache above, dealing with collections and with
+        objects that were not rewritten. """
+        if isinstance(original, tuple):
+            return tuple([from_cache(c) for c in original])
+        elif isinstance(original, FrozenOrderedSet):
+            return ordered_set(*[from_cache(c) for c in original])
+        elif isinstance(original, CLONABLE):
+            return cache.get(original.id, original)
+        else:
+            return original
+
+    # the last node that was processed and rewritten
+    prev_node = None
+    stack: list[ir.Node] = [task]
+    def to_stack(original):
+        """ Add this original node to the stack if it is clonable and was never processed;
+        return True iff the node was added to the stack. """
+        if isinstance(original, CLONABLE) and original.id not in cache:
+            stack.append(original)
+            return True
+        return False
+
+    while stack:
+        # peek the current node and get the initializable fields (i.e. ignore Node id)
+        curr = stack[-1]
+        curr_fields = list(filter(lambda f: f.init, fields(curr)))
+        stacked_children = False
+
+        # go over the fields adding to the stack the ones that we need to rewrite
+        for field in curr_fields:
+            field_value = getattr(curr, field.name)
+            if isinstance(field_value, (tuple, FrozenOrderedSet)):
+                # node field is a collection (tuple or set)
+                for s in field_value:
+                    if isinstance(s, tuple):
+                        # the value within the collection is a tuple (can happen for lookup args)
+                        for c in s:
+                            stacked_children = to_stack(c) or stacked_children
+                    else:
+                        # the value within the collection is a scalar
+                        stacked_children = to_stack(s) or stacked_children
+            else:
+                # node field is a scalar
+                stacked_children = to_stack(field_value) or stacked_children
+
+        # if no childrean were stacked, we rewrote all fields of curr, so we can pop it and rewrite it
+        if not stacked_children:
+            stack.pop()
+            children = []
+            for f in curr_fields:
+                children.append(from_cache(getattr(curr, f.name)))
+            # create a new prev_node with the cloned children
+            prev_node = curr.__class__(*children)
+            cache[curr.id] = prev_node
+
+    # the last node we processed is the rewritten original node
+    assert(isinstance(prev_node, type(task)))
+    return prev_node