MindsDB 25.9.1.0__py3-none-any.whl → 25.9.1.1__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.9.1.0"
+__version__ = "25.9.1.1"
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = "MindsDB Inc"

mindsdb/__main__.py

@@ -417,7 +417,7 @@ if __name__ == "__main__":
             name=TrunkProcessEnum.HTTP.value,
             entrypoint=start_http,
             port=http_api_config["port"],
-            args=(config.cmd_args.verbose, config.cmd_args.no_studio),
+            args=(config.cmd_args.verbose,),
             restart_on_failure=http_api_config.get("restart_on_failure", False),
             max_restart_count=http_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
             max_restart_interval_seconds=http_api_config.get(

mindsdb/api/executor/utilities/mysql_to_duckdb_functions.py

@@ -1,7 +1,33 @@
-from mindsdb_sql_parser.ast import Identifier, Function, Constant, BinaryOperation
+import re
+from mindsdb_sql_parser.ast import Identifier, Function, Constant, BinaryOperation, Interval, ASTNode, UnaryOperation
 
 
-def adapt_char_fn(node: Function) -> Function | None:
+# ---- helper -----
+
+
+def cast(node: ASTNode, typename: str) -> BinaryOperation:
+    return BinaryOperation("::", args=[node, Identifier(typename)])
+
+
+def date_part(node, part):
+    """
+    Wrap element into DATE_PART function
+
+    Docs:
+        https://duckdb.org/docs/stable/sql/functions/date#date_partpart-date
+    """
+    node.args = apply_nested_functions(node.args)
+
+    if len(node.args) != 1:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    return Function("DATE_PART", args=[Constant(part), cast(node.args[0], "date")])
+
+
+# ------------------------------
+
+
+def char_fn(node: Function) -> Function | None:
     """Replace MySQL's multy-arg CHAR call to chain of DuckDB's CHR calls
 
     Example:
@@ -30,7 +56,7 @@ def adapt_char_fn(node: Function) -> Function | None:
     return acc
 
 
-def adapt_locate_fn(node: Function) -> Function | None:
+def locate_fn(node: Function) -> Function | None:
     """Replace MySQL's LOCATE (or INSTR) call to DuckDB's STRPOS call
 
     Example:
@@ -56,7 +82,7 @@ def adapt_locate_fn(node: Function) -> Function | None:
     node.op = "strpos"
 
 
-def adapt_unhex_fn(node: Function) -> None:
+def unhex_fn(node: Function) -> None:
     """Check MySQL's UNHEX function call arguments to ensure they are strings,
     because DuckDB's UNHEX accepts only string arguments, while MySQL's UNHEX can accept integer arguments.
     NOTE: if return dataframe from duckdb then unhex values are array - this may be an issue
@@ -75,7 +101,7 @@ def adapt_unhex_fn(node: Function) -> None:
             raise ValueError("MySQL UNHEX function argument must be a string")
 
 
-def adapt_format_fn(node: Function) -> None:
+def format_fn(node: Function) -> None:
     """Adapt MySQL's FORMAT function to DuckDB's FORMAT function
 
     Example:
@@ -113,7 +139,7 @@ def adapt_format_fn(node: Function) -> None:
         node.args[0] = Constant(f"{{:,.{decimal_places}f}}")
 
 
-def adapt_sha2_fn(node: Function) -> None:
+def sha2_fn(node: Function) -> None:
     """Adapt MySQL's SHA2 function to DuckDB's SHA256 function
 
     Example:
@@ -134,7 +160,7 @@ def adapt_sha2_fn(node: Function) -> None:
     node.args = [node.args[0]]
 
 
-def adapt_length_fn(node: Function) -> None:
+def length_fn(node: Function) -> None:
     """Adapt MySQL's LENGTH function to DuckDB's STRLEN function
     NOTE: duckdb also have LENGTH, therefore it can not be used
 
@@ -150,7 +176,7 @@ def adapt_length_fn(node: Function) -> None:
     node.op = "strlen"
 
 
-def adapt_regexp_substr_fn(node: Function) -> None:
+def regexp_substr_fn(node: Function) -> None:
     """Adapt MySQL's REGEXP_SUBSTR function to DuckDB's REGEXP_EXTRACT function
 
     Example:
@@ -177,7 +203,7 @@ def adapt_regexp_substr_fn(node: Function) -> None:
     node.op = "regexp_extract"
 
 
-def adapt_substring_index_fn(node: Function) -> BinaryOperation | Function:
+def substring_index_fn(node: Function) -> BinaryOperation | Function:
     """Adapt MySQL's SUBSTRING_INDEX function to DuckDB's SPLIT_PART function
 
     Example:
@@ -210,7 +236,7 @@ def adapt_substring_index_fn(node: Function) -> BinaryOperation | Function:
     return acc
 
 
-def adapt_curtime_fn(node: Function) -> BinaryOperation:
+def curtime_fn(node: Function) -> BinaryOperation:
     """Adapt MySQL's CURTIME function to DuckDB's GET_CURRENT_TIME function.
     To get the same type as MySQL's CURTIME function, we need to cast the result to time type.
 
@@ -223,10 +249,10 @@ def adapt_curtime_fn(node: Function) -> BinaryOperation:
     Returns:
         BinaryOperation: Binary operation node
     """
-    return BinaryOperation("::", args=[Function(op="get_current_time", args=[]), Identifier("time")], alias=node.alias)
+    return cast(Function(op="get_current_time", args=[]), "time")
 
 
-def adapt_timestampdiff_fn(node: Function) -> None:
+def timestampdiff_fn(node: Function) -> None:
     """Adapt MySQL's TIMESTAMPDIFF function to DuckDB's DATE_DIFF function
     NOTE: Looks like cast string args to timestamp works in most cases, but there may be some exceptions.
 
@@ -241,11 +267,11 @@ def adapt_timestampdiff_fn(node: Function) -> None:
     """
     node.op = "date_diff"
     node.args[0] = Constant(node.args[0].parts[0])
-    node.args[1] = BinaryOperation(" ", args=[Identifier("timestamp"), node.args[1]])
-    node.args[2] = BinaryOperation(" ", args=[Identifier("timestamp"), node.args[2]])
+    node.args[1] = cast(node.args[1], "timestamp")
+    node.args[2] = cast(node.args[2], "timestamp")
 
 
-def adapt_extract_fn(node: Function) -> None:
+def extract_fn(node: Function) -> None:
     """Adapt MySQL's EXTRACT function to DuckDB's EXTRACT function
     TODO: multi-part args, like YEAR_MONTH, is not supported yet
     NOTE: Looks like adding 'timestamp' works in most cases, but there may be some exceptions.
@@ -259,6 +285,428 @@ def adapt_extract_fn(node: Function) -> None:
     Returns:
         None
     """
-    node.args[0] = Constant(node.args[0].parts[0])
-    if not isinstance(node.from_arg, Identifier):
-        node.from_arg = BinaryOperation(" ", args=[Identifier("timestamp"), node.from_arg])
+    part = node.args[0].parts[0]
+    if part.upper() == "YEAR_MONTH":
+        node.args = apply_nested_functions([node.from_arg, Constant("%Y%m")])
+        node.from_arg = None
+        date_format_fn(node)
+        return cast(node, "int")
+    elif part.upper() == "DAY_MINUTE":
+        node.args = apply_nested_functions([node.from_arg, Constant("%e%H%i")])
+        node.from_arg = None
+        date_format_fn(node)
+        return cast(node, "int")
+    else:
+        node.args[0] = Constant(part)
+        if not isinstance(node.from_arg, Identifier):
+            node.from_arg = cast(node.from_arg, "timestamp")
+
+
+def get_format_fn(node: Function) -> Constant:
+    """
+    Replace function with a constant according to table:
+    Important! The parameters can be only constants.
+
+    Example: GET_FORMAT(DATE, 'USA') => '%m.%d.%Y'
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_get-format
+    """
+
+    if len(node.args) != 2:
+        raise ValueError("MySQL GET_FORMAT supports only 2 arguments")
+
+    arg1, arg2 = node.args
+
+    if not isinstance(arg1, Identifier) and len(arg1.parts) != 1:
+        raise ValueError(f"Unknown type: {arg1}")
+
+    if not isinstance(arg2, Constant):
+        raise ValueError(f"Unknown format name: {arg2}")
+
+    match arg1.parts[0].upper(), arg2.value.upper():
+        case "DATE", "USA":
+            value = "%m.%d.%Y"
+        case "DATE", "JIS":
+            value = "%Y-%m-%d"
+        case "DATE", "ISO":
+            value = "%Y-%m-%d"
+        case "DATE", "EUR":
+            value = "%d.%m.%Y"
+        case "DATE", "INTERNAL":
+            value = "%Y%m%d"
+
+        case "DATETIME", "USA":
+            value = "%Y-%m-%d %H.%i.%s"
+        case "DATETIME", "JIS":
+            value = "%Y-%m-%d %H:%i:%s"
+        case "DATETIME", "ISO":
+            value = "%Y-%m-%d %H:%i:%s"
+        case "DATETIME", "EUR":
+            value = "%Y-%m-%d %H.%i.%s"
+        case "DATETIME", "INTERNAL":
+            value = "%Y%m%d%H%i%s"
+
+        case "TIME", "USA":
+            value = "%h:%i:%s %p"
+        case "TIME", "JIS":
+            value = "%H:%i:%s"
+        case "TIME", "ISO":
+            value = "%H:%i:%s"
+        case "TIME", "EUR":
+            value = "%H.%i.%s"
+        case "TIME", "INTERNAL":
+            value = "%H%i%s"
+
+        case _:
+            value = ""
+
+    return Constant(value)
+
+
+def date_format_fn(node: Function):
+    """
+    Adapt to strftime function and convert keys in format string.
+
+      DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y')
+        =>
+      strftime('2009-10-04 22:23:00'::datetime, '%A %B %Y')
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_date-format
+        https://duckdb.org/docs/stable/sql/functions/timestamp.html#strftimetimestamp-format
+        https://duckdb.org/docs/stable/sql/functions/dateformat.html#format-specifiers
+    """
+    specifiers_map = {
+        "%c": "%-m",  # Month, numeric (0..12) -> Month as decimal
+        "%D": "%-d",  # Day with English suffix -> Day as decimal (no suffix in DuckDB)
+        "%e": "%-d",  # Day of month (0..31) -> Day as decimal
+        "%h": "%I",  # Hour (01..12)
+        "%i": "%M",  # Minutes
+        "%j": "%j",  # Day of year
+        "%k": "%-H",  # Hour (0..23) -> Hour as decimal
+        "%l": "%-I",  # Hour (1..12) -> Hour as decimal
+        "%M": "%B",  # Month name -> Full month name
+        "%r": "%I:%M:%S %p",  # Time, 12-hour
+        "%s": "%S",  # Seconds
+        "%T": "%X",  # Time, 24-hour
+        "%u": "%V",  # Week, mode 1, Monday is first day, can be wrong in the edges of year
+        "%v": "%V",  # Week, mode 3, Monday is first day
+        "%V": "%U",  # Week, mode 2, Sunday is first day, can be wrong in the edges of year
+        "%W": "%A",  # Weekday name -> Full weekday name
+        "%X": "%G",  # Year for week
+        "%x": "%G",  # Year for week
+    }
+    node.op = "strftime"
+
+    node.args = apply_nested_functions(node.args)
+
+    if len(node.args) != 2 or not isinstance(node.args[1], Constant):
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    def repl_f(match):
+        specifier = match.group()
+        return specifiers_map.get(specifier, specifier)
+
+    # adapt format string
+    node.args[1].value = re.sub(r"%[a-zA-Z]", repl_f, node.args[1].value)
+
+    # add type casting
+    node.args[0] = cast(node.args[0], "timestamp")
+
+
+def from_unixtime_fn(node):
+    """
+    Adapt to make_timestamp function
+        FROM_UNIXTIME(1447430881) => make_timestamp((1447430881::int8 *1000000))
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_from-unixtime
+        https://duckdb.org/docs/stable/sql/functions/timestamp#make_timestampmicroseconds
+    """
+
+    if len(node.args) != 1:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    node.op = "make_timestamp"
+
+    node.args[0] = BinaryOperation("*", args=[cast(node.args[0], "int8"), Constant(1_000_000)])
+
+
+def from_days_fn(node):
+    """
+    Adapt to converting days to interval and adding to first day of the 0 year:
+        FROM_DAYS(735669)  => '0000-01-01'::date + (735669 * INTERVAL '1 day')
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_from-days
+    """
+    node.args = apply_nested_functions(node.args)
+
+    if len(node.args) != 1:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    return BinaryOperation(
+        op="+",
+        args=[
+            BinaryOperation("::", args=[Constant("0000-01-01"), Identifier("date")]),
+            BinaryOperation("*", args=[node.args[0], Interval("1 day")]),
+        ],
+    )
+
+
+def dayofyear_fn(node):
+    """
+    Addapt to DATE_PART:
+        DAYOFYEAR('2007-02-03') => DATE_PART('doy', '2007-02-03'::date)
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_dayofyear
+    """
+
+    return date_part(node, "doy")
+
+
+def dayofweek_fn(node):
+    """
+    Addapt to DATE_PART:
+        DAYOFWEEK('2007-02-03'); => DATE_PART('dow', '2007-02-03'::date) + 1;
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_dayofweek
+    """
+    return BinaryOperation("+", args=[date_part(node, "dow"), Constant(1)])
+
+
+def dayofmonth_fn(node):
+    """
+    Addapt to DATE_PART:
+        DAYOFMONTH('2007-02-03') => DATE_PART('day', '2007-02-03'::date)
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_dayofmonth
+    """
+
+    return date_part(node, "day")
+
+
+def dayname_fn(node):
+    """
+    Use the same function with type casting
+        DAYNAME('2007-02-03') => DAYNAME('2007-02-03'::date)
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_dayname
+    """
+    if len(node.args) != 1:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    node.args[0] = cast(node.args[0], "date")
+
+
+def curdate_fn(node):
+    """
+    Replace the name of the function
+        CURDATE() => CURRENT_DATE()
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_curdate
+        https://duckdb.org/docs/stable/sql/functions/date.html#current_date
+    """
+    node.op = "CURRENT_DATE"
+
+
+def datediff_fn(node):
+    """
+    Change argument's order and cast to date:
+        DATEDIFF('2007-12-31 23:59:59','2007-11-30') => datediff('day',DATE '2007-11-30', DATE '2007-12-31 23:59:59')
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_datediff
+        https://duckdb.org/docs/stable/sql/functions/date#date_diffpart-startdate-enddate
+
+    """
+    if len(node.args) != 2:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    arg1, arg2 = node.args
+    node.args = [Constant("day"), cast(arg2, "date"), cast(arg1, "date")]
+
+
+def adddate_fn(node):
+    """
+    Replace the name of the function and add type casting
+    Important! The second parameter can be only interval (not count of days).
+        SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY) => SELECT DATE_ADD('2008-01-02'::date, INTERVAL 31 DAY)
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_adddate
+        https://duckdb.org/docs/stable/sql/functions/date.html#date_adddate-interval
+    """
+    if len(node.args) != 2:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    node.op = "DATE_ADD"
+    node.args[0] = cast(node.args[0], "timestamp")
+
+
+def date_sub_fn(node):
+    """
+    Use DATE_ADD with negative interval
+        SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY) => select DATE_ADD('1998-01-02'::date, -INTERVAL 31 DAY)
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_date-add
+        https://duckdb.org/docs/stable/sql/functions/date.html#date_adddate-interval
+    """
+    if len(node.args) != 2:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    node.op = "DATE_ADD"
+    node.args[0] = cast(node.args[0], "timestamp")
+    node.args[1] = UnaryOperation("-", args=[node.args[1]])
+
+
+def addtime_fn(node):
+    """
+    Convert second parameter into interval.
+    Important!
+        - The second parameter can be only a constant.
+        - The first parameter can be only date/datetime (not just time)
+
+      ADDTIME('2007-12-31', '1 1:1:1.2')
+        =>
+      DATE_ADD('2007-12-31'::timestamp, INTERVAL '1 day 1 hour 1 minute 1.2 second')
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_addtime
+        https://duckdb.org/docs/stable/sql/functions/date.html#date_adddate-interval
+    """
+    node.args = apply_nested_functions(node.args)
+
+    if len(node.args) != 2:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    interval = node.args[1]
+    if not isinstance(interval, Constant) or not isinstance(interval.value, str):
+        raise ValueError(f"The second argument have to be string: {node.args[1]}")
+
+    pattern = r"^(?:(\d+)\s+)?(?:(\d+):)?(?:(\d+):)?(\d+)(?:\.(\d+))?$"
+
+    match = re.match(pattern, interval.value)
+    if not match:
+        raise ValueError(f"Invalid MySQL time format: {interval.value}")
+
+    # Extract components
+    days, hours, minutes, seconds, fractional = match.groups()
+    # Build interval string
+    parts = []
+    if days and int(days) > 0:
+        parts.append(f"{days} day")
+
+    if hours and int(hours) > 0:
+        parts.append(f"{int(hours)} hour")
+
+    if minutes and int(minutes) > 0:
+        parts.append(f"{int(minutes)} minute")
+
+    seconds = int(seconds) if seconds else 0
+    fractional = float(f"0.{fractional}") if fractional else 0.0
+    total_seconds = seconds + fractional
+    if total_seconds > 0:
+        seconds_str = str(total_seconds).rstrip("0").rstrip(".")
+        parts.append(f"{seconds_str} second")
+
+    # If all components are zero, return 0 seconds
+    if not parts:
+        interval_str = "0 second"
+    else:
+        interval_str = " ".join(parts)
+
+    return Function(
+        "DATE_ADD",
+        args=[
+            cast(node.args[0], "timestamp"),
+            Interval(interval_str),
+        ],
+    )
+
+
+def convert_tz_fn(node):
+    """
+    Concatenate timezone to first argument and cast it as timestamptz. Then use `timezone` function
+    Important! Duckdb doesn't recognize timezones in digital formats: +10:00
+
+      CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')
+        =>
+      timezone('MET', ('2004-01-01 12:00:00' || ' ' || 'GMT')::timestamptz);
+
+    Docs:
+        https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_convert-tz
+        https://duckdb.org/docs/stable/sql/functions/timestamptz.html#timezonetext-timestamp
+    """
+    node.args = apply_nested_functions(node.args)
+
+    if len(node.args) != 3:
+        raise ValueError(f"Wrong arguments: {node.args}")
+
+    date, tzfrom, tzto = node.args
+
+    # concatenate tz name: date || ' ' || tzfrom
+    tzdate = BinaryOperation("||", args=[BinaryOperation("||", args=[date, Constant(" ")]), tzfrom], parentheses=True)
+
+    return Function(
+        "timezone",
+        args=[
+            tzto,
+            cast(tzdate, "timestamptz"),
+        ],
+    )
+
+
+def apply_nested_functions(args):
+    args2 = []
+    for arg in args:
+        if isinstance(arg, Function):
+            fnc = mysql_to_duckdb_fnc(arg)
+            if args2 is not None:
+                arg = fnc(arg)
+        args2.append(arg)
+    return args2
+
+
+def mysql_to_duckdb_fnc(node):
+    fnc_name = node.op.lower()
+
+    mysql_to_duck_fn_map = {
+        "char": char_fn,
+        "locate": locate_fn,
+        "insrt": locate_fn,
+        "unhex": unhex_fn,
+        "format": format_fn,
+        "sha2": sha2_fn,
+        "length": length_fn,
+        "regexp_substr": regexp_substr_fn,
+        "substring_index": substring_index_fn,
+        "curtime": curtime_fn,
+        "timestampdiff": timestampdiff_fn,
+        "extract": extract_fn,
+        "get_format": get_format_fn,
+        "date_format": date_format_fn,
+        "from_unixtime": from_unixtime_fn,
+        "from_days": from_days_fn,
+        "dayofyear": dayofyear_fn,
+        "dayofweek": dayofweek_fn,
+        "day": dayofmonth_fn,
+        "dayofmonth": dayofmonth_fn,
+        "dayname": dayname_fn,
+        "curdate": curdate_fn,
+        "datediff": datediff_fn,
+        "adddate": adddate_fn,
+        "date_sub": date_sub_fn,
+        "date_add": adddate_fn,
+        "addtime": addtime_fn,
+        "convert_tz": convert_tz_fn,
+    }
+    if fnc_name in mysql_to_duck_fn_map:
+        return mysql_to_duck_fn_map[fnc_name]

mindsdb/api/executor/utilities/sql.py

@@ -14,19 +14,7 @@ from mindsdb.utilities.exception import format_db_error_message
 from mindsdb.utilities.functions import resolve_table_identifier, resolve_model_identifier
 from mindsdb.utilities.json_encoder import CustomJSONEncoder
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
-from mindsdb.api.executor.utilities.mysql_to_duckdb_functions import (
-    adapt_char_fn,
-    adapt_locate_fn,
-    adapt_unhex_fn,
-    adapt_format_fn,
-    adapt_sha2_fn,
-    adapt_length_fn,
-    adapt_regexp_substr_fn,
-    adapt_substring_index_fn,
-    adapt_curtime_fn,
-    adapt_timestampdiff_fn,
-    adapt_extract_fn,
-)
+from mindsdb.api.executor.utilities.mysql_to_duckdb_functions import mysql_to_duckdb_fnc
 
 logger = log.getLogger(__name__)
 
@@ -196,25 +184,15 @@ def query_df(df, query, session=None):
                 node.parts = [node.parts[-1]]
                 return node
         if isinstance(node, Function):
-            fnc_name = node.op.lower()
-
-            mysql_to_duck_fn_map = {
-                "char": adapt_char_fn,
-                "locate": adapt_locate_fn,
-                "insrt": adapt_locate_fn,
-                "unhex": adapt_unhex_fn,
-                "format": adapt_format_fn,
-                "sha2": adapt_sha2_fn,
-                "length": adapt_length_fn,
-                "regexp_substr": adapt_regexp_substr_fn,
-                "substring_index": adapt_substring_index_fn,
-                "curtime": adapt_curtime_fn,
-                "timestampdiff": adapt_timestampdiff_fn,
-                "extract": adapt_extract_fn,
-            }
-            if fnc_name in mysql_to_duck_fn_map:
-                return mysql_to_duck_fn_map[fnc_name](node)
+            fnc = mysql_to_duckdb_fnc(node)
+            if fnc is not None:
+                node2 = fnc(node)
+                if node2 is not None:
+                    # copy alias
+                    node2.alias = node.alias
+                return node2
 
+            fnc_name = node.op.lower()
             if fnc_name == "database" and len(node.args) == 0:
                 if session is not None:
                     cur_db = session.database