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

mindsdb/api/common/middleware.py

@@ -0,0 +1,106 @@
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+from starlette.requests import Request
+from http import HTTPStatus
+from typing import Optional
+import secrets
+import hmac
+import hashlib
+import os
+import traceback
+
+from mindsdb.utilities import log
+from mindsdb.utilities.config import config
+
+logger = log.getLogger(__name__)
+
+SECRET_KEY = os.environ.get("AUTH_SECRET_KEY") or secrets.token_urlsafe(32)
+# We store token (fingerprints) in memory, which means everyone is logged out if the process restarts
+TOKENS = []
+
+
+def get_pat_fingerprint(token: str) -> str:
+    """Hash the token with HMAC-SHA256 using secret_key as pepper."""
+    return hmac.new(SECRET_KEY.encode(), token.encode(), hashlib.sha256).hexdigest()
+
+
+def generate_pat() -> str:
+    logger.debug("Generating new auth token")
+    token = "pat_" + secrets.token_urlsafe(32)
+    TOKENS.append(get_pat_fingerprint(token))
+    return token
+
+
+def verify_pat(raw_token: str) -> bool:
+    """Verify if the raw_token matches a stored fingerprint.
+    Returns token_id if valid, None if not.
+    """
+    if not raw_token:
+        return False
+    fp = get_pat_fingerprint(raw_token)
+    for stored_fp in TOKENS:
+        if hmac.compare_digest(fp, stored_fp):
+            return True
+    return False
+
+
+def revoke_pat(raw_token: str) -> bool:
+    """Revoke raw_token from active tokens"""
+    if not raw_token:
+        return False
+    fp = get_pat_fingerprint(raw_token)
+    for stored_fp in TOKENS:
+        if hmac.compare_digest(fp, stored_fp):
+            TOKENS.remove(stored_fp)
+            return True
+    return False
+
+
+class PATAuthMiddleware(BaseHTTPMiddleware):
+    def _extract_bearer(self, request: Request) -> Optional[str]:
+        h = request.headers.get("Authorization")
+        if not h or not h.startswith("Bearer "):
+            return None
+        return h.split(" ", 1)[1].strip() or None
+
+    async def dispatch(self, request: Request, call_next):
+        if config.get("auth", {}).get("http_auth_enabled", False) is False:
+            return await call_next(request)
+
+        token = self._extract_bearer(request)
+        if not token or not verify_pat(token):
+            return JSONResponse({"detail": "Unauthorized"}, status_code=HTTPStatus.UNAUTHORIZED)
+
+        request.state.user = config["auth"].get("username")
+        return await call_next(request)
+
+
+# Used by mysql and postgres protocols
+def check_auth(username, password, scramble_func, salt, company_id, config):
+    try:
+        hardcoded_user = config["auth"].get("username")
+        hardcoded_password = config["auth"].get("password")
+        if hardcoded_password is None:
+            hardcoded_password = ""
+        hardcoded_password_hash = scramble_func(hardcoded_password, salt)
+        hardcoded_password = hardcoded_password.encode()
+
+        if password is None:
+            password = ""
+        if isinstance(password, str):
+            password = password.encode()
+
+        if username != hardcoded_user:
+            logger.warning(f"Check auth, user={username}: user mismatch")
+            return {"success": False}
+
+        if password != hardcoded_password and password != hardcoded_password_hash:
+            logger.warning(f"check auth, user={username}: password mismatch")
+            return {"success": False}
+
+        logger.info(f"Check auth, user={username}: Ok")
+        return {"success": True, "username": username}
+    except Exception as e:
+        logger.error(f"Check auth, user={username}: ERROR")
+        logger.error(e)
+        logger.error(traceback.format_exc())

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]