fakesnow 0.9.5__py3-none-any.whl → 0.9.7__py3-none-any.whl

fakesnow/fakes.py

@@ -173,7 +173,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.drop_schema_cascade)
             .transform(transforms.tag)
             .transform(transforms.semi_structured_types)
-            .transform(transforms.parse_json)
+            .transform(transforms.try_parse_json)
             # indices_to_json_extract must be before regex_substr
             .transform(transforms.indices_to_json_extract)
             .transform(transforms.json_extract_cast_as_varchar)
@@ -185,6 +185,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.values_columns)
             .transform(transforms.to_date)
             .transform(transforms.to_decimal)
+            .transform(transforms.try_to_decimal)
             .transform(transforms.to_timestamp_ntz)
             .transform(transforms.to_timestamp)
             .transform(transforms.object_construct)
@@ -196,11 +197,20 @@ class FakeSnowflakeCursor:
             .transform(transforms.array_size)
             .transform(transforms.random)
             .transform(transforms.identifier)
+            .transform(transforms.array_agg_within_group)
+            .transform(transforms.array_agg_to_json)
+            .transform(transforms.dateadd_date_cast)
+            .transform(transforms.dateadd_string_literal_timestamp_cast)
+            .transform(transforms.datediff_string_literal_timestamp_cast)
             .transform(lambda e: transforms.show_schemas(e, self._conn.database))
             .transform(lambda e: transforms.show_objects_tables(e, self._conn.database))
-            .transform(lambda e: transforms.show_primary_keys(e, self._conn.database))
+            # TODO collapse into a single show_keys function
+            .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="PRIMARY"))
+            .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="UNIQUE"))
+            .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="FOREIGN"))
             .transform(transforms.show_users)
             .transform(transforms.create_user)
+            .transform(transforms.sha256)
         )
         sql = transformed.sql(dialect="duckdb")
         result_sql = None
@@ -614,7 +624,9 @@ class FakeSnowflakeConnection:
             # don't jsonify string
             df[col] = df[col].apply(lambda x: json.dumps(x) if isinstance(x, (dict, list)) else x)
 
-        self._duck_conn.execute(f"INSERT INTO {table_name}({','.join(df.columns.to_list())}) SELECT * FROM df")
+        escaped_cols = ",".join(f'"{col}"' for col in df.columns.to_list())
+        self._duck_conn.execute(f"INSERT INTO {table_name}({escaped_cols}) SELECT * FROM df")
+
         return self._duck_conn.fetchall()[0][0]
 
 

fakesnow/info_schema.py

@@ -1,4 +1,5 @@
 """Info schema extension tables/views used for storing snowflake metadata not captured by duckdb."""
+
 from __future__ import annotations
 
 from string import Template

fakesnow/transforms.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pathlib import Path
 from string import Template
-from typing import cast
+from typing import ClassVar, Literal, cast
 
 import sqlglot
 from sqlglot import exp
@@ -22,6 +22,39 @@ def array_size(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def array_agg_to_json(expression: exp.Expression) -> exp.Expression:
+    if isinstance(expression, exp.ArrayAgg):
+        return exp.Anonymous(this="TO_JSON", expressions=[expression])
+
+    return expression
+
+
+def array_agg_within_group(expression: exp.Expression) -> exp.Expression:
+    """Convert ARRAY_AGG(<expr>) WITHIN GROUP (<order-by-clause>) to ARRAY_AGG( <expr> <order-by-clause> )
+    Snowflake uses ARRAY_AGG(<expr>) WITHIN GROUP (ORDER BY <order-by-clause>)
+    to order the array, but DuckDB uses ARRAY_AGG( <expr> <order-by-clause> ).
+    See;
+        - https://docs.snowflake.com/en/sql-reference/functions/array_agg
+        - https://duckdb.org/docs/sql/aggregates.html#order-by-clause-in-aggregate-functions
+    Note; Snowflake has following restriction;
+            If you specify DISTINCT and WITHIN GROUP, both must refer to the same column.
+          Transformation does not handle this restriction.
+    """
+    if (
+        isinstance(expression, exp.WithinGroup)
+        and (agg := expression.find(exp.ArrayAgg))
+        and (order := expression.expression)
+    ):
+        return exp.ArrayAgg(
+            this=exp.Order(
+                this=agg.this,
+                expressions=order.expressions,
+            )
+        )
+
+    return expression
+
+
 # TODO: move this into a Dialect as a transpilation
 def create_database(expression: exp.Expression, db_path: Path | None = None) -> exp.Expression:
     """Transform create database to attach database.
@@ -38,7 +71,8 @@ def create_database(expression: exp.Expression, db_path: Path | None = None) ->
     """
 
     if isinstance(expression, exp.Create) and str(expression.args.get("kind")).upper() == "DATABASE":
-        assert (ident := expression.find(exp.Identifier)), f"No identifier in {expression.sql}"
+        ident = expression.find(exp.Identifier)
+        assert ident, f"No identifier in {expression.sql}"
         db_name = ident.this
         db_file = f"{db_path/db_name}.db" if db_path else ":memory:"
 
@@ -135,6 +169,98 @@ def drop_schema_cascade(expression: exp.Expression) -> exp.Expression:
     return new
 
 
+def dateadd_date_cast(expression: exp.Expression) -> exp.Expression:
+    """Cast result of DATEADD to DATE if the given expression is a cast to DATE
+       and unit is either DAY, WEEK, MONTH or YEAR to mimic Snowflake's DATEADD
+       behaviour.
+
+    Snowflake;
+        SELECT DATEADD(DAY, 3, '2023-03-03'::DATE) as D;
+            D: 2023-03-06 (DATE)
+    DuckDB;
+        SELECT CAST('2023-03-03' AS DATE) + INTERVAL 3 DAY AS D
+            D: 2023-03-06 00:00:00 (TIMESTAMP)
+    """
+
+    if not isinstance(expression, exp.DateAdd):
+        return expression
+
+    if expression.unit is None:
+        return expression
+
+    if not isinstance(expression.unit.this, str):
+        return expression
+
+    if (unit := expression.unit.this.upper()) and unit.upper() not in {"DAY", "WEEK", "MONTH", "YEAR"}:
+        return expression
+
+    if not isinstance(expression.this, exp.Cast):
+        return expression
+
+    if expression.this.to.this != exp.DataType.Type.DATE:
+        return expression
+
+    return exp.Cast(
+        this=expression,
+        to=exp.DataType(this=exp.DataType.Type.DATE, nested=False, prefix=False),
+    )
+
+
+def dateadd_string_literal_timestamp_cast(expression: exp.Expression) -> exp.Expression:
+    """Snowflake's DATEADD function implicitly casts string literals to
+    timestamps regardless of unit.
+    """
+    if not isinstance(expression, exp.DateAdd):
+        return expression
+
+    if not isinstance(expression.this, exp.Literal) or not expression.this.is_string:
+        return expression
+
+    new_dateadd = expression.copy()
+    new_dateadd.set(
+        "this",
+        exp.Cast(
+            this=expression.this,
+            # TODO: support TIMESTAMP_TYPE_MAPPING of TIMESTAMP_LTZ/TZ
+            to=exp.DataType(this=exp.DataType.Type.TIMESTAMP, nested=False, prefix=False),
+        ),
+    )
+
+    return new_dateadd
+
+
+def datediff_string_literal_timestamp_cast(expression: exp.Expression) -> exp.Expression:
+    """Snowflake's DATEDIFF function implicitly casts string literals to
+    timestamps regardless of unit.
+    """
+
+    if not isinstance(expression, exp.DateDiff):
+        return expression
+
+    op1 = expression.this.copy()
+    op2 = expression.expression.copy()
+
+    if isinstance(op1, exp.Literal) and op1.is_string:
+        op1 = exp.Cast(
+            this=op1,
+            # TODO: support TIMESTAMP_TYPE_MAPPING of TIMESTAMP_LTZ/TZ
+            to=exp.DataType(this=exp.DataType.Type.TIMESTAMP, nested=False, prefix=False),
+        )
+
+    if isinstance(op2, exp.Literal) and op2.is_string:
+        op2 = exp.Cast(
+            this=op2,
+            # TODO: support TIMESTAMP_TYPE_MAPPING of TIMESTAMP_LTZ/TZ
+            to=exp.DataType(this=exp.DataType.Type.TIMESTAMP, nested=False, prefix=False),
+        )
+
+    new_datediff = expression.copy()
+    new_datediff.set("this", op1)
+    new_datediff.set("expression", op2)
+
+    return new_datediff
+
+
 def extract_comment_on_columns(expression: exp.Expression) -> exp.Expression:
     """Extract column comments, removing it from the Expression.
 
@@ -507,38 +633,26 @@ def object_construct(expression: exp.Expression) -> exp.Expression:
     """
 
     if isinstance(expression, exp.Struct):
-        # remove expressions containing NULL
-        for enull in expression.find_all(exp.Null):
-            if enull.parent:
-                enull.parent.pop()
+        non_null_expressions = []
+        for e in expression.expressions:
+            if not (isinstance(e, exp.PropertyEQ)):
+                non_null_expressions.append(e)
+                continue
 
-        return exp.Anonymous(this="TO_JSON", expressions=[expression])
+            left = e.left
+            right = e.right
 
-    return expression
+            left_is_null = isinstance(left, exp.Null)
+            right_is_null = isinstance(right, exp.Null)
 
+            if left_is_null or right_is_null:
+                continue
 
-def parse_json(expression: exp.Expression) -> exp.Expression:
-    """Convert parse_json() to json().
+            non_null_expressions.append(e)
 
-    Example:
-        >>> import sqlglot
-        >>> sqlglot.parse_one("insert into table1 (name) select parse_json('{}')").transform(parse_json).sql()
-        "CREATE TABLE table1 (name JSON)"
-    Args:
-        expression (exp.Expression): the expression that will be transformed.
-
-    Returns:
-        exp.Expression: The transformed expression.
-    """
-
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "PARSE_JSON"
-    ):
-        new = expression.copy()
-        new.args["this"] = "JSON"
-        return new
+        new_struct = expression.copy()
+        new_struct.set("expressions", non_null_expressions)
+        return exp.Anonymous(this="TO_JSON", expressions=[new_struct])
 
     return expression
 
@@ -681,55 +795,61 @@ def set_schema(expression: exp.Expression, current_database: str | None) -> exp.
     return expression
 
 
-SQL_SHOW_OBJECTS = """
-select
-    to_timestamp(0)::timestamptz as 'created_on',
-    table_name as 'name',
-    case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind',
-    table_catalog as 'database_name',
-    table_schema as 'schema_name'
-from information_schema.tables
-"""
-
-
 def show_objects_tables(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
     """Transform SHOW OBJECTS/TABLES to a query against the information_schema.tables table.
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-objects
         https://docs.snowflake.com/en/sql-reference/sql/show-tables
     """
-    if (
+    if not (
         isinstance(expression, exp.Show)
         and isinstance(expression.this, str)
-        and expression.this.upper() in ["OBJECTS", "TABLES"]
+        and (show := expression.this.upper())
+        and show in {"OBJECTS", "TABLES"}
     ):
-        scope_kind = expression.args.get("scope_kind")
-        table = expression.find(exp.Table)
-
-        if scope_kind == "DATABASE":
-            catalog = (table and table.name) or current_database
-            schema = None
-        elif scope_kind == "SCHEMA" and table:
-            catalog = table.db or current_database
-            schema = table.name
-        else:
-            # all objects / tables
-            catalog = None
-            schema = None
-
-        tables_only = "table_type = 'BASE TABLE' and " if expression.this.upper() == "TABLES" else ""
-        exclude_fakesnow_tables = "not (table_schema == 'information_schema' and table_name like '_fs_%%')"
-        # without a database will show everything in the "account"
-        table_catalog = f" and table_catalog = '{catalog}'" if catalog else ""
-        schema = f" and table_schema = '{schema}'" if schema else ""
-        limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
+        return expression
 
-        return sqlglot.parse_one(
-            f"{SQL_SHOW_OBJECTS} where {tables_only}{exclude_fakesnow_tables}{table_catalog}{schema}{limit}",
-            read="duckdb",
-        )
-
-    return expression
+    scope_kind = expression.args.get("scope_kind")
+    table = expression.find(exp.Table)
+
+    if scope_kind == "DATABASE":
+        catalog = (table and table.name) or current_database
+        schema = None
+    elif scope_kind == "SCHEMA" and table:
+        catalog = table.db or current_database
+        schema = table.name
+    else:
+        # all objects / tables
+        catalog = None
+        schema = None
+
+    tables_only = "table_type = 'BASE TABLE' and " if show == "TABLES" else ""
+    exclude_fakesnow_tables = "not (table_schema == 'information_schema' and table_name like '_fs_%%')"
+    # without a database will show everything in the "account"
+    table_catalog = f" and table_catalog = '{catalog}'" if catalog else ""
+    schema = f" and table_schema = '{schema}'" if schema else ""
+    limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
+
+    columns = [
+        "to_timestamp(0)::timestamptz as 'created_on'",
+        "table_name as 'name'",
+        "case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind'",
+        "table_catalog as 'database_name'",
+        "table_schema as 'schema_name'",
+    ]
+
+    terse = expression.args["terse"]
+    if not terse:
+        columns.append('null as "comment"')
+
+    columns_str = ", ".join(columns)
+
+    query = (
+        f"SELECT {columns_str} from information_schema.tables "
+        f"where {tables_only}{exclude_fakesnow_tables}{table_catalog}{schema}{limit}"
+    )
+
+    return sqlglot.parse_one(query, read="duckdb")
 
 
 SQL_SHOW_SCHEMAS = """
@@ -822,30 +942,107 @@ def to_date(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def _get_to_number_args(e: exp.ToNumber) -> tuple[exp.Expression | None, exp.Expression | None, exp.Expression | None]:
+    arg_format = e.args.get("format")
+    arg_precision = e.args.get("precision")
+    arg_scale = e.args.get("scale")
+
+    _format = None
+    _precision = None
+    _scale = None
+
+    # to_number(value, <format>, <precision>, <scale>)
+    if arg_format:
+        if arg_format.is_string:
+            # to_number('100', 'TM9' ...)
+            _format = arg_format
+
+            # to_number('100', 'TM9', 10 ...)
+            if arg_precision:
+                _precision = arg_precision
+
+                # to_number('100', 'TM9', 10, 2)
+                if arg_scale:
+                    _scale = arg_scale
+            else:
+                pass
+        else:
+            # to_number('100', 10, ...)
+            # arg_format is not a string, so it must be precision.
+            _precision = arg_format
+
+            # to_number('100', 10, 2)
+            # And arg_precision must be scale
+            if arg_precision:
+                _scale = arg_precision
+    else:
+        # If format is not provided, just check for precision and scale directly
+        if arg_precision:
+            _precision = arg_precision
+            if arg_scale:
+                _scale = arg_scale
+
+    return _format, _precision, _scale
+
+
+def _to_decimal(expression: exp.Expression, cast_node: type[exp.Cast]) -> exp.Expression:
+    expressions: list[exp.Expression] = expression.expressions
+
+    if len(expressions) > 1 and expressions[1].is_string:
+        # see https://docs.snowflake.com/en/sql-reference/functions/to_decimal#arguments
+        raise NotImplementedError(f"{expression.this} with format argument")
+
+    precision = expressions[1] if len(expressions) > 1 else exp.Literal(this="38", is_string=False)
+    scale = expressions[2] if len(expressions) > 2 else exp.Literal(this="0", is_string=False)
+
+    return cast_node(
+        this=expressions[0],
+        to=exp.DataType(this=exp.DataType.Type.DECIMAL, expressions=[precision, scale], nested=False, prefix=False),
+    )
+
+
 def to_decimal(expression: exp.Expression) -> exp.Expression:
     """Transform to_decimal, to_number, to_numeric expressions from snowflake to duckdb.
 
     See https://docs.snowflake.com/en/sql-reference/functions/to_decimal
     """
 
+    if isinstance(expression, exp.ToNumber):
+        format_, precision, scale = _get_to_number_args(expression)
+        if format_:
+            raise NotImplementedError(f"{expression.this} with format argument")
+
+        if not precision:
+            precision = exp.Literal(this="38", is_string=False)
+        if not scale:
+            scale = exp.Literal(this="0", is_string=False)
+
+        return exp.Cast(
+            this=expression.this,
+            to=exp.DataType(this=exp.DataType.Type.DECIMAL, expressions=[precision, scale], nested=False, prefix=False),
+        )
+
     if (
         isinstance(expression, exp.Anonymous)
         and isinstance(expression.this, str)
-        and expression.this.upper() in ["TO_DECIMAL", "TO_NUMBER", "TO_NUMERIC"]
+        and expression.this.upper() in ["TO_DECIMAL", "TO_NUMERIC"]
     ):
-        expressions: list[exp.Expression] = expression.expressions
+        return _to_decimal(expression, exp.Cast)
 
-        if len(expressions) > 1 and expressions[1].is_string:
-            # see https://docs.snowflake.com/en/sql-reference/functions/to_decimal#arguments
-            raise NotImplementedError(f"{expression.this} with format argument")
+    return expression
 
-        precision = expressions[1] if len(expressions) > 1 else exp.Literal(this="38", is_string=False)
-        scale = expressions[2] if len(expressions) > 2 else exp.Literal(this="0", is_string=False)
 
-        return exp.Cast(
-            this=expressions[0],
-            to=exp.DataType(this=exp.DataType.Type.DECIMAL, expressions=[precision, scale], nested=False, prefix=False),
-        )
+def try_to_decimal(expression: exp.Expression) -> exp.Expression:
+    """Transform try_to_decimal, try_to_number, try_to_numeric expressions from snowflake to duckdb.
+    See https://docs.snowflake.com/en/sql-reference/functions/try_to_decimal
+    """
+
+    if (
+        isinstance(expression, exp.Anonymous)
+        and isinstance(expression.this, str)
+        and expression.this.upper() in ["TRY_TO_DECIMAL", "TRY_TO_NUMBER", "TRY_TO_NUMERIC"]
+    ):
+        return _to_decimal(expression, exp.TryCast)
 
     return expression
 
@@ -898,6 +1095,34 @@ def timestamp_ntz_ns(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def try_parse_json(expression: exp.Expression) -> exp.Expression:
+    """Convert TRY_PARSE_JSON() to TRY_CAST(... as JSON).
+
+    Example:
+        >>> import sqlglot
+        >>> sqlglot.parse_one("select try_parse_json('{}')").transform(parse_json).sql()
+        "SELECT TRY_CAST('{}' AS JSON)"
+    Args:
+        expression (exp.Expression): the expression that will be transformed.
+
+    Returns:
+        exp.Expression: The transformed expression.
+    """
+
+    if (
+        isinstance(expression, exp.Anonymous)
+        and isinstance(expression.this, str)
+        and expression.this.upper() == "TRY_PARSE_JSON"
+    ):
+        expressions = expression.expressions
+        return exp.TryCast(
+            this=expressions[0],
+            to=exp.DataType(this=exp.DataType.Type.JSON, nested=False),
+        )
+
+    return expression
+
+
 # sqlglot.parse_one("create table example(date TIMESTAMP_NTZ(9));", read="snowflake")
 def semi_structured_types(expression: exp.Expression) -> exp.Expression:
     """Convert OBJECT, ARRAY, and VARIANT types to duckdb compatible types.
@@ -999,32 +1224,70 @@ def create_user(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def show_primary_keys(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
-    """Transform SHOW PRIMARY KEYS to a query against the duckdb_constraints table.
+def show_keys(
+    expression: exp.Expression,
+    current_database: str | None = None,
+    *,
+    kind: Literal["PRIMARY", "UNIQUE", "FOREIGN"],
+) -> exp.Expression:
+    """Transform SHOW <kind> KEYS to a query against the duckdb_constraints meta-table.
 
     https://docs.snowflake.com/en/sql-reference/sql/show-primary-keys
     """
+    snowflake_kind = kind
+    if kind == "FOREIGN":
+        snowflake_kind = "IMPORTED"
+
     if (
         isinstance(expression, exp.Show)
         and isinstance(expression.this, str)
-        and expression.this.upper() == "PRIMARY KEYS"
+        and expression.this.upper() == f"{snowflake_kind} KEYS"
     ):
-        statement = f"""
-            SELECT
-                to_timestamp(0)::timestamptz as created_on,
-                database_name as database_name,
-                schema_name as schema_name,
-                table_name as table_name,
-                unnest(constraint_column_names) as column_name,
-                1 as key_sequence,
-                LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS constraint_name,
-                'false' as rely,
-                null as comment
-            FROM duckdb_constraints
-            WHERE constraint_type = 'PRIMARY KEY'
-              AND database_name = '{current_database}'
-              AND table_name NOT LIKE '_fs_%'
-            """
+        if kind == "FOREIGN":
+            statement = f"""
+                SELECT
+                    to_timestamp(0)::timestamptz as created_on,
+
+                    '' as pk_database_name,
+                    '' as pk_schema_name,
+                    '' as pk_table_name,
+                    '' as pk_column_name,
+                    unnest(constraint_column_names) as pk_column_name,
+
+                    database_name as fk_database_name,
+                    schema_name as fk_schema_name,
+                    table_name as fk_table_name,
+                    unnest(constraint_column_names) as fk_column_name,
+                    1 as key_sequence,
+                    'NO ACTION' as update_rule,
+                    'NO ACTION' as delete_rule,
+                    LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS fk_name,
+                    LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS pk_name,
+                    'NOT DEFERRABLE' as deferrability,
+                    'false' as rely,
+                    null as "comment"
+                FROM duckdb_constraints
+                WHERE constraint_type = 'PRIMARY KEY'
+                  AND database_name = '{current_database}'
+                  AND table_name NOT LIKE '_fs_%'
+                """
+        else:
+            statement = f"""
+                SELECT
+                    to_timestamp(0)::timestamptz as created_on,
+                    database_name as database_name,
+                    schema_name as schema_name,
+                    table_name as table_name,
+                    unnest(constraint_column_names) as column_name,
+                    1 as key_sequence,
+                    LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS constraint_name,
+                    'false' as rely,
+                    null as "comment"
+                FROM duckdb_constraints
+                WHERE constraint_type = '{kind} KEY'
+                  AND database_name = '{current_database}'
+                  AND table_name NOT LIKE '_fs_%'
+                """
 
         scope_kind = expression.args.get("scope_kind")
         if scope_kind:
@@ -1042,3 +1305,48 @@ def show_primary_keys(expression: exp.Expression, current_database: str | None =
                 raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind} not yet supported")
         return sqlglot.parse_one(statement)
     return expression
+
+
+class SHA256(exp.Func):
+    _sql_names: ClassVar = ["SHA256"]
+    arg_types: ClassVar = {"this": True}
+
+
+def sha256(expression: exp.Expression) -> exp.Expression:
+    """Convert sha2() or sha2_hex() to sha256().
+
+    Convert sha2_binary() to unhex(sha256()).
+
+    Example:
+        >>> import sqlglot
+        >>> sqlglot.parse_one("insert into table1 (name) select sha2('foo')").transform(sha256).sql()
+        "INSERT INTO table1 (name) SELECT SHA256('foo')"
+    Args:
+        expression (exp.Expression): the expression that will be transformed.
+
+    Returns:
+        exp.Expression: The transformed expression.
+    """
+
+    if isinstance(expression, exp.SHA2) and expression.args.get("length", exp.Literal.number(256)).this == "256":
+        return SHA256(this=expression.this)
+    elif (
+        isinstance(expression, exp.Anonymous)
+        and expression.this.upper() == "SHA2_HEX"
+        and (
+            len(expression.expressions) == 1
+            or (len(expression.expressions) == 2 and expression.expressions[1].this == "256")
+        )
+    ):
+        return SHA256(this=expression.expressions[0])
+    elif (
+        isinstance(expression, exp.Anonymous)
+        and expression.this.upper() == "SHA2_BINARY"
+        and (
+            len(expression.expressions) == 1
+            or (len(expression.expressions) == 2 and expression.expressions[1].this == "256")
+        )
+    ):
+        return exp.Unhex(this=SHA256(this=expression.expressions[0]))
+
+    return expression

{fakesnow-0.9.5.dist-info → fakesnow-0.9.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.5
+Version: 0.9.7
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License: Apache License
                                    Version 2.0, January 2004
@@ -213,15 +213,15 @@ License-File: LICENSE
 Requires-Dist: duckdb ~=0.10.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot ~=21.1.0
+Requires-Dist: sqlglot ~=23.3.0
 Provides-Extra: dev
-Requires-Dist: black ~=23.9 ; extra == 'dev'
 Requires-Dist: build ~=1.0 ; extra == 'dev'
+Requires-Dist: pandas-stubs ; extra == 'dev'
 Requires-Dist: snowflake-connector-python[pandas,secure-local-storage] ; extra == 'dev'
 Requires-Dist: pre-commit ~=3.4 ; extra == 'dev'
-Requires-Dist: pytest ~=7.4 ; extra == 'dev'
-Requires-Dist: ruff ~=0.1.6 ; extra == 'dev'
-Requires-Dist: twine ~=4.0 ; extra == 'dev'
+Requires-Dist: pytest ~=8.0 ; extra == 'dev'
+Requires-Dist: ruff ~=0.3.2 ; extra == 'dev'
+Requires-Dist: twine ~=5.0 ; extra == 'dev'
 Requires-Dist: snowflake-sqlalchemy ~=1.5.0 ; extra == 'dev'
 Provides-Extra: notebook
 Requires-Dist: duckdb-engine ; extra == 'notebook'
@@ -233,6 +233,7 @@ Requires-Dist: jupysql ; extra == 'notebook'
 [![ci](https://github.com/tekumara/fakesnow/actions/workflows/ci.yml/badge.svg)](https://github.com/tekumara/fakesnow/actions/workflows/ci.yml)
 [![release](https://github.com/tekumara/fakesnow/actions/workflows/release.yml/badge.svg)](https://github.com/tekumara/fakesnow/actions/workflows/release.yml)
 [![PyPI](https://img.shields.io/pypi/v/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 
 Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector). Run and mock Snowflake DB locally.
 

{fakesnow-0.9.5.dist-info → fakesnow-0.9.7.dist-info}/RECORD

@@ -3,16 +3,16 @@ fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
 fakesnow/checks.py,sha256=-QMvdcrRbhN60rnzxLBJ0IkUBWyLR8gGGKKmCS0w9mA,2383
 fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
 fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
-fakesnow/fakes.py,sha256=MhZeKSY602Pdl2XMNoHAgs_ZB5ROUJjEWlZlueNUw6Y,28205
+fakesnow/fakes.py,sha256=3tTPaAC1vBaTLmSG92o51QA0AzIT9XDieYiZsMzvY9M,28929
 fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
 fakesnow/global_database.py,sha256=WTVIP1VhNvdCeX7TQncX1TRpGQU5rBf5Pbxim40zeSU,1399
-fakesnow/info_schema.py,sha256=9UfkGYdjJHTHSk9rbWqxlFUcLGhrS3CyGwP-gkS3A6Q,6265
+fakesnow/info_schema.py,sha256=CdIcGXHEQ_kmEAzdQKvA-PX41LA6wlK-4p1J45qgKYA,6266
 fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
 fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
-fakesnow/transforms.py,sha256=jYzJ6EeObd-MgNdOKjkFD1usmP8wZGqT6rQd2KrtUMM,38424
-fakesnow-0.9.5.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
-fakesnow-0.9.5.dist-info/METADATA,sha256=R5uWClyMFddD_7wrovBLhw2EkgKzCLdMf8jy6TIe0pE,17719
-fakesnow-0.9.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-fakesnow-0.9.5.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.5.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
-fakesnow-0.9.5.dist-info/RECORD,,
+fakesnow/transforms.py,sha256=77hqWLWsZNvi6fLrn-JhIIeDy8CgiJ-zlNIAm8rQLf0,48818
+fakesnow-0.9.7.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.7.dist-info/METADATA,sha256=ISDnq1yQPohGORq0isidKp11g_vWYt37rdtWz2vaoKE,17831
+fakesnow-0.9.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+fakesnow-0.9.7.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.7.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
+fakesnow-0.9.7.dist-info/RECORD,,

{fakesnow-0.9.5.dist-info → fakesnow-0.9.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any