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

relationalai/semantics/std/datetime.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+from typing import Union, Literal
+import datetime as dt
+
+from relationalai.semantics.internal import internal as b
+from .std import _DateTime, _Date, _Integer, _String, _make_expr
+from .. import std
+
+class ISO:
+    DATE = "yyyy-mm-dd"
+    HOURS = "yyyy-mm-ddTHH"
+    HOURS_TZ = "yyyy-mm-ddTHHz"
+    MINUTES = "yyyy-mm-ddTHH:MM"
+    MINUTES_TZ = "yyyy-mm-ddTHH:MMz"
+    SECONDS = "yyyy-mm-ddTHH:MM:SS"
+    SECONDS_TZ = "yyyy-mm-ddTHH:MM:SSz"
+    MILLIS = "yyyy-mm-ddTHH:MM:SS.s"
+    MILLIS_TZ = "yyyy-mm-ddTHH:MM:SS.sz"
+
+#--------------------------------------------------
+# Date functions
+#--------------------------------------------------
+
+class date:
+
+    def __new__(cls, year: _Integer, month: _Integer, day: _Integer) -> b.Expression:
+        return _make_expr("construct_date", std.cast_to_int64(year), std.cast_to_int64(month), std.cast_to_int64(day), b.Date.ref("res"))
+
+    @classmethod
+    def year(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_year", date, b.Int64.ref("res"))
+
+    @classmethod
+    def quarter(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_quarter", date, b.Int64.ref("res"))
+
+    @classmethod
+    def month(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_month", date, b.Int64.ref("res"))
+
+    @classmethod
+    def week(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_week", date, b.Int64.ref("res"))
+
+    @classmethod
+    def day(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_day", date, b.Int64.ref("res"))
+
+    @classmethod
+    def dayofyear(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_dayofyear", date, b.Int64.ref("res"))
+
+    @classmethod
+    def isoweekday(cls, date: _Date) -> b.Expression:
+        """
+        Return the ISO weekday as an integer, where Monday is 1, and Sunday is 7.
+        """
+        return _make_expr("date_weekday", date, b.Int64.ref("res"))
+
+    @classmethod
+    def weekday(cls, date: _Date) -> b.Expression:
+        return cls.isoweekday(date) - 1 # Convert ISO weekday (1=Mon..7=Sun) to weekday (0=Mon..6=Sun)
+
+    @classmethod
+    def fromordinal(cls, ordinal: _Integer) -> b.Expression:
+        # ordinal 1 = '0001-01-01'. Minus 1 day since we can't declare date 0000-00-00
+        return cls.add(b.Date(dt.date(1, 1, 1)), days(ordinal - 1))
+
+    @classmethod
+    def to_datetime(cls, date: _Date, hour: int = 0, minute: int = 0, second: int = 0, millisecond: int = 0, tz: str = "UTC") -> b.Expression:
+        _year = cls.year(date)
+        _month = cls.month(date)
+        _day = cls.day(date)
+        return _make_expr("construct_datetime_ms_tz", _year, _month, _day, hour, minute, second, millisecond, tz, b.DateTime.ref("res"))
+
+    @classmethod
+    def format(cls, date: _Date, format: _String) -> b.Expression:
+        return _make_expr("date_format", date, format, b.String.ref("res"))
+
+    @classmethod
+    def add(cls, date: _Date, period: b.Producer) -> b.Expression:
+        return _make_expr("date_add", date, period, b.Date.ref("res"))
+
+    @classmethod
+    def subtract(cls, date: _Date, period: b.Producer) -> b.Expression:
+        return _make_expr("date_subtract", date, period, b.Date.ref("res"))
+
+    @classmethod
+    def range(cls, start: _Date | None = None, end: _Date | None = None, periods: int = 1, freq: Frequency = "D") -> b.Expression:
+        """
+        Note on date_ranges and datetime_range: The way the computation works is that it first overapproximates the
+        number of periods.
+
+        For example, date_range(2025-02-01, 2025-03-01, freq='M') and date_range(2025-02-01, 2025-03-31, freq='M') will
+        compute range_end to be ceil(28*1/(365/12))=1 and ceil(58*1/(365/12))=2.
+
+        Then, the computation fetches range_end+1 items into _date, which is the right number in the first case but
+        one too many in the second case. That's why a filter end >= _date (or variant of) is applied, to remove any
+        extra item. The result is two items in both cases.
+        """
+        if start is None and end is None:
+            raise ValueError("Invalid start/end date for date_range. Must provide at least start date or end date")
+        _days = {
+            "D": 1,
+            "W": 1/7,
+            "M": 1/(365/12),
+            "Y": 1/365,
+        }
+        if freq not in _days.keys():
+            raise ValueError(f"Frequency '{freq}' is not allowed for date_range. List of allowed frequencies: {list(_days.keys())}")
+        date_func = cls.add
+        if start is None:
+            start = end
+            end = None
+            date_func = cls.subtract
+        assert start is not None
+        if end is not None:
+            num_days = cls.period_days(start, end)
+            if freq in ["W", "M", "Y"]:
+                range_end = std.cast(b.Int64, std.math.ceil(num_days * _days[freq]))
+            else:
+                range_end = num_days
+            # date_range is inclusive. add 1 since std.range is exclusive
+            ix = std.range(0, range_end + 1, 1)
+        else:
+            ix = std.range(0, periods, 1)
+        _date = date_func(start, _periods[freq](ix))
+        if isinstance(end, dt.date) :
+            return b.Date(end) >= _date
+        elif end is not None:
+            return end >= _date
+        return _date
+
+    @classmethod
+    def period_days(cls, start: _Date, end: _Date) -> b.Expression:
+        return _make_expr("dates_period_days", start, end, b.Int64.ref("res"))
+
+    @classmethod
+    def fromisoformat(cls, date_string: _String) -> b.Expression:
+        return _make_expr("parse_date", date_string, ISO.DATE, b.Date.ref("res"))
+
+#--------------------------------------------------
+# DateTime functions
+#--------------------------------------------------
+
+class datetime:
+
+    def __new__(cls, year: _Integer, month: _Integer, day: _Integer, hour: _Integer = 0, minute: _Integer = 0,
+             second: _Integer = 0, millisecond: _Integer = 0, tz: dt.tzinfo|_String = "UTC") -> b.Expression:
+        if isinstance(tz, dt.tzinfo):
+            tz = str(tz)
+        return _make_expr("construct_datetime_ms_tz", std.cast_to_int64(year), std.cast_to_int64(month),
+                          std.cast_to_int64(day), std.cast_to_int64(hour), std.cast_to_int64(minute),
+                          std.cast_to_int64(second), std.cast_to_int64(millisecond), tz, b.DateTime.ref("res"))
+
+    @classmethod
+    def now(cls) -> b.Expression:
+        return _make_expr("datetime_now", b.DateTime.ref("res"))
+
+    @classmethod
+    def year(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_year", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def quarter(cls, datetime: _DateTime,  tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_quarter", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def month(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_month", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def week(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_week", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def day(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_day", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def dayofyear(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_dayofyear", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def hour(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_hour", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def minute(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_minute", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def second(cls, datetime: _DateTime) -> b.Expression:
+        return _make_expr("datetime_second", datetime, b.Int64.ref("res"))
+
+    @classmethod
+    def isoweekday(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        """
+        Return the ISO weekday as an integer, where Monday is 1, and Sunday is 7.
+        """
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_weekday", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def weekday(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        return cls.isoweekday(datetime, tz) - 1 # Convert ISO weekday (1=Mon..7=Sun) to weekday (0=Mon..6=Sun)
+
+    @classmethod
+    def fromordinal(cls, ordinal: _Integer) -> b.Expression:
+        # Convert ordinal to milliseconds, since ordinals in Python are days
+        # Minus 1 day since we can't declare date 0000-00-00
+        ordinal_milliseconds = (ordinal - 1) * 86400000 # 24 * 60 * 60 * 1000
+        return cls.add(b.DateTime(dt.datetime(1, 1, 1, 0, 0, 0)), milliseconds(ordinal_milliseconds))
+
+    @classmethod
+    def strptime(cls, date_str: _String, format: _String) -> b.Expression:
+        return _make_expr("parse_datetime", date_str, format, b.DateTime.ref("res"))
+
+    @classmethod
+    def to_date(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("construct_date_from_datetime", datetime, tz, b.Date.ref("res"))
+
+    @classmethod
+    def format(cls, date: _DateTime, format: _String, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(date, tz)
+        return _make_expr("datetime_format", date, format, tz, b.String.ref("res"))
+
+    @classmethod
+    def add(cls, date: _DateTime, period: b.Producer) -> b.Expression:
+        return _make_expr("datetime_add", date, period, b.DateTime.ref("res"))
+
+    @classmethod
+    def subtract(cls, date: _DateTime, period: b.Producer) -> b.Expression:
+        return _make_expr("datetime_subtract", date, period, b.DateTime.ref("res"))
+
+    @classmethod
+    def range(cls, start: _DateTime | None = None, end: _DateTime | None = None, periods: int = 1, freq: Frequency = "D") -> b.Expression:
+        """
+        Note on date_ranges and datetime_range: The way the computation works is that it first overapproximates the
+        number of periods.
+
+        For example, date_range(2025-02-01, 2025-03-01, freq='M') and date_range(2025-02-01, 2025-03-31, freq='M') will
+        compute range_end to be ceil(28*1/(365/12))=1 and ceil(58*1/(365/12))=2.
+
+        Then, the computation fetches range_end+1 items into _date, which is the right number in the first case but
+        one too many in the second case. That's why a filter end >= _date (or variant of) is applied, to remove any
+        extra item. The result is two items in both cases.
+        """
+        if start is None and end is None:
+            raise ValueError("Invalid start/end datetime for datetime_range. Must provide at least start datetime or end datetime")
+        _milliseconds = {
+            "ms": 1,
+            "s": 1 / 1_000,
+            "m": 1 / 60_000,
+            "H": 1 / 3_600_000,
+            "D": 1 / 86_400_000,
+            "W": 1 / (86_400_000 * 7),
+            "M": 1 / (86_400_000 * (365 / 12)),
+            "Y": 1 / (86_400_000 * 365),
+        }
+        date_func = cls.add
+        if start is None:
+            start = end
+            end = None
+            date_func = cls.subtract
+        assert start is not None
+        if end is not None:
+            num_ms = cls.period_milliseconds(start, end)
+            if freq == "ms":
+                _end = num_ms
+            else:
+                _end = std.cast(b.Int64, std.math.ceil(num_ms * _milliseconds[freq]))
+            # datetime_range is inclusive. add 1 since std.range is exclusive
+            ix = std.range(0, _end + 1, 1)
+        else:
+            ix = std.range(0, periods, 1)
+        _date = date_func(start, _periods[freq](ix))
+        if isinstance(end, dt.datetime) :
+            return b.DateTime(end) >= _date
+        elif end is not None:
+            return end >= _date
+        return _date
+
+    @classmethod
+    def period_milliseconds(cls, start: _DateTime, end: _DateTime) -> b.Expression:
+        return _make_expr("datetimes_period_milliseconds", start, end, b.Int64.ref("res"))
+
+#--------------------------------------------------
+# Periods
+#--------------------------------------------------
+
+def nanoseconds(period: _Integer) -> b.Expression:
+    return _make_expr("nanosecond", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def microseconds(period: _Integer) -> b.Expression:
+    return _make_expr("microsecond", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def milliseconds(period: _Integer) -> b.Expression:
+    return _make_expr("millisecond", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def seconds(period: _Integer) -> b.Expression:
+    return _make_expr("second", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def minutes(period: _Integer) -> b.Expression:
+    return _make_expr("minute", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def hours(period: _Integer) -> b.Expression:
+    return _make_expr("hour", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def days(period: _Integer) -> b.Expression:
+    return _make_expr("day", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def weeks(period: _Integer) -> b.Expression:
+    return _make_expr("week", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def months(period: _Integer) -> b.Expression:
+    return _make_expr("month", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def years(period: _Integer) -> b.Expression:
+    return _make_expr("year", std.cast_to_int64(period), b.Int64.ref("res"))
+
+
+Frequency = Union[
+    Literal["ms"],
+    Literal["s"],
+    Literal["m"],
+    Literal["H"],
+    Literal["D"],
+    Literal["W"],
+    Literal["M"],
+    Literal["Y"],
+]
+
+_periods = {
+    "ms": milliseconds,
+    "s": seconds,
+    "m": minutes,
+    "H": hours,
+    "D": days,
+    "W": weeks,
+    "M": months,
+    "Y": years,
+}
+
+def _extract_tz(datetime: _DateTime, tz: dt.tzinfo|_String|None) -> _String:
+    default_tz = "UTC"
+    if tz is None:
+        if isinstance(datetime, dt.datetime):
+            tz = datetime.tzname() or default_tz
+        else:
+            tz = default_tz
+    elif isinstance(tz, dt.tzinfo) :
+        tz = tz.tzname(None) or default_tz
+    return tz

relationalai/semantics/std/math.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from relationalai.semantics.internal import internal as b
 from .std import _Number, _make_expr
+from math import pi
 
 def abs(value: _Number) -> b.Expression:
     return _make_expr("abs", value, b.Number.ref("res"))
@@ -9,6 +10,17 @@ def abs(value: _Number) -> b.Expression:
 def natural_log(value: _Number) -> b.Expression:
     return _make_expr("natural_log", value, b.Number.ref("res"))
 
+def log(value: _Number, base: _Number | None = None) -> b.Expression:
+    if base is None:
+        return _make_expr("natural_log", value, b.Number.ref("res"))
+    return _make_expr("log", value, base, b.Number.ref("res"))
+
+def log2(value: _Number) -> b.Expression:
+    return _make_expr("log", value, 2, b.Number.ref("res"))
+
+def log10(value: _Number) -> b.Expression:
+    return _make_expr("log10", value, b.Number.ref("res"))
+
 def sqrt(value: _Number) -> b.Expression:
     return _make_expr("sqrt", value, b.Float.ref("res"))
 
@@ -62,3 +74,68 @@ def asin(value: _Number) -> b.Expression:
 
 def asinh(value: _Number) -> b.Expression:
     return _make_expr("asinh", value, b.Float.ref("res"))
+
+def tan(value: _Number) -> b.Expression:
+    return _make_expr("tan", value, b.Float.ref("res"))
+
+def tanh(value: _Number) -> b.Expression:
+    return _make_expr("tanh", value, b.Float.ref("res"))
+
+def atan(value: _Number) -> b.Expression:
+    return _make_expr("atan", value, b.Float.ref("res"))
+
+def atanh(value: _Number) -> b.Expression:
+    return _make_expr("atanh", value, b.Float.ref("res"))
+
+def cot(value: _Number) -> b.Expression:
+    return _make_expr("cot", value, b.Float.ref("res"))
+
+def acot(value: _Number) -> b.Expression:
+    return _make_expr("acot", value, b.Float.ref("res"))
+
+def degrees(value: _Number) -> b.Expression:
+    divisor = pi / 180.0
+    return _make_expr("/", value, divisor, b.Float.ref("res"))
+
+def radians(value: _Number) -> b.Expression:
+    divisor = 180.0 / pi
+    return _make_expr("/", value, divisor, b.Float.ref("res"))
+
+def exp(value: _Number) -> b.Expression:
+    return _make_expr("exp", value, b.Float.ref("res"))
+
+def erf(value: _Number) -> b.Expression:
+    return _make_expr("erf", value, b.Float.ref("res"))
+
+def erfinv(value: _Number) -> b.Expression:
+    return _make_expr("erfinv", value, b.Float.ref("res"))
+
+def haversine(x1: _Number, y1: _Number, x2: _Number, y2: _Number, r: _Number) -> b.Expression:
+    # 2 * r * asin[sqrt[sin[(x2 - x1)/2] ^ 2 + cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2]]
+    # sin[(x2 - x1)/2] ^ 2
+    x_diff = _make_expr("-", x2, x1, b.Float.ref("x_diff"))
+    x_diff2 = _make_expr("/", x_diff, 2.0, b.Float.ref("x_diff2"))
+    sin_x_diff = _make_expr("sin", x_diff2, b.Float.ref("sin_x_diff"))
+    sin_x_pow = _make_expr("pow", sin_x_diff, 2.0, b.Float.ref("sin_x_pow"))
+
+    # cos[x1] * cos[x2]
+    cos_x1 = _make_expr("cos", x1, b.Float.ref("cos_x1"))
+    cos_x2 = _make_expr("cos", x2, b.Float.ref("cos_x2"))
+    cos_x1_x2 = _make_expr("*", cos_x1, cos_x2, b.Float.ref("cos_x1_x2"))
+
+    # sin[(y2 - y1) / 2] ^ 2
+    y_diff = _make_expr("-", y2, y1, b.Float.ref("y_diff"))
+    y_diff2 = _make_expr("/", y_diff, 2.0, b.Float.ref("y_diff2"))
+    sin_y_diff = _make_expr("sin", y_diff2, b.Float.ref("sin_y_diff"))
+    sin_y_pow = _make_expr("pow", sin_y_diff, 2.0, b.Float.ref("sin_y_pow"))
+
+    # cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2
+    prod = _make_expr("*", cos_x1_x2, sin_y_pow, b.Float.ref("prod"))
+    # sin[(x2 - x1)/2] ^ 2 + cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2
+    prod_sum = _make_expr("+", sin_x_pow, prod, b.Float.ref("prod_sum"))
+
+    sqrt_val = _make_expr("sqrt", prod_sum, b.Float.ref("sqrt_val"))
+    asin_val = _make_expr("asin", sqrt_val, b.Float.ref("asin_val"))
+    haversine_r = _make_expr("*", r, asin_val, b.Float.ref("haversine_r"))
+    haversine_final = _make_expr("*", haversine_r, 2.0, b.Float.ref("haversine_final"))
+    return haversine_final

relationalai/semantics/std/re.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from relationalai.semantics.internal import internal as i
+from relationalai.semantics.metamodel.util import OrderedSet
+from .std import _Integer, _String, _make_expr
+from typing import Literal, Any
+from .. import std
+
+
+def escape(regex: _String) -> i.Expression:
+    return _make_expr("escape_regex_metachars", regex, i.String.ref())
+
+class Match(i.Producer):
+
+    def __init__(self, regex: _String, string: _String, pos: _Integer = 0, _type: Literal["search", "fullmatch", "match"] = "match"):
+        super().__init__(i.find_model([regex, string, pos]))
+        self.regex = regex
+        self.string = string
+        self.pos = pos
+
+        if _type == "match":
+            self._expr = _regex_match_all(self.regex, self.string, std.cast_to_int64(self.pos + 1))
+            self._offset, self._full_match = self._expr._arg_ref(2), self._expr._arg_ref(3)
+        elif _type == "search":
+            raise NotImplementedError("`search` is not implemented")
+        elif _type == "fullmatch":
+            _exp = _regex_match_all(self.regex, self.string, std.cast_to_int64(self.pos + 1))
+            self._offset, self._full_match = _exp._arg_ref(2), _exp._arg_ref(3)
+            self._expr = self._full_match == std.strings.substring(self.string, std.cast_to_int64(self.pos), std.strings.len(self.string))
+
+    def group(self, index: _Integer = 0) -> i.Producer:
+        if index == 0:
+            return self._full_match
+        else:
+            return _make_expr("capture_group_by_index", self.regex, self.string, std.cast_to_int64(self.pos + 1), std.cast_to_int64(index), i.String.ref("res"))
+
+    def group_by_name(self, name: _String) -> i.Producer:
+        return _make_expr("capture_group_by_name", self.regex, self.string, std.cast_to_int64(self.pos + 1), name, i.String.ref("res"))
+
+    def start(self) -> i.Expression:
+        return self._offset - 1
+
+    def end(self) -> i.Expression:
+        return std.strings.len(self.group(0)) + self.start() - 1
+
+    def span(self) -> tuple[i.Producer, i.Producer]:
+        return self.start(), self.end()
+
+    def _to_keys(self) -> OrderedSet[Any]:
+        return i.find_keys(self._expr)
+
+    def _compile_lookup(self, compiler:i.Compiler, ctx:i.CompilerContext):
+        compiler.lookup(self.regex, ctx)
+        compiler.lookup(self.string, ctx)
+        compiler.lookup(self.pos, ctx)
+        return compiler.lookup(self._expr, ctx)
+
+    def __getattr__(self, name: str) -> Any:
+        return object.__getattribute__(self, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        object.__setattr__(self, name, value)
+
+
+def match(regex: _String, string: _String) -> Match:
+    return Match(regex, string)
+
+def search(regex: _String, string: _String, pos: _Integer = 0) -> Match:
+    return Match(regex, string, pos, _type="search")
+
+def fullmatch(regex: _String, string: _String, pos: _Integer = 0) -> Match:
+    return Match(regex, string, pos, _type="fullmatch")
+
+def findall(regex: _String, string: _String) -> tuple[i.Producer, i.Producer]:
+    exp = _regex_match_all(regex, string)
+    ix, match = exp._arg_ref(2), exp._arg_ref(3)
+    rank = i.rank(i.asc(ix, match))
+    return rank, match
+
+def _regex_match_all(regex: _String, string: _String, pos: _Integer|None = None) -> i.Expression:
+    if pos is None:
+        pos = i.Int64.ref()
+    return _make_expr("regex_match_all", regex, string, pos, i.String.ref())

relationalai/semantics/std/strings.py

@@ -15,7 +15,7 @@ def concat(s0: _String, s1: _String, *args: _String) -> b.Expression:
     return res
 
 def len(s: _String) -> b.Expression:
-    return _make_expr("num_chars", s, b.Int128.ref("res"))
+    return _make_expr("num_chars", s, b.Int64.ref("res"))
 
 def startswith(s0: _String, s1: _String) -> b.Expression:
     return _make_expr("starts_with", s0, s1)