sqlframe 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

sqlframe/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.4.0'
-__version_tuple__ = version_tuple = (1, 4, 0)
+__version__ = version = '1.5.1'
+__version_tuple__ = version_tuple = (1, 5, 1)

sqlframe/base/column.py

@@ -251,6 +251,13 @@ class Column:
             return lit(value)
         return Column(value)
 
+    @property
+    def dtype(self) -> t.Optional[DataType]:
+        expression = self.expression.unalias()
+        if isinstance(expression, exp.Cast):
+            return expression.args.get("to")
+        return None
+
     def copy(self) -> Column:
         return Column(self.expression.copy())
 

sqlframe/base/function_alternatives.py

@@ -7,6 +7,7 @@ import typing as t
 
 from sqlglot import exp as expression
 from sqlglot.helper import ensure_list
+from sqlglot.helper import flatten as _flatten
 
 from sqlframe.base.column import Column
 from sqlframe.base.util import get_func_from_session
@@ -60,6 +61,10 @@ def first_always_ignore_nulls(col: ColumnOrName, ignorenulls: t.Optional[bool] =
     return first(col)
 
 
+def bitwise_not_from_bitnot(col: ColumnOrName) -> Column:
+    return Column.invoke_anonymous_function(col, "BITNOT")
+
+
 def factorial_from_case_statement(col: ColumnOrName) -> Column:
     from sqlframe.base.session import _BaseSession
 
@@ -160,6 +165,10 @@ def factorial_ensure_int(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col_func(col).cast("integer"), "FACTORIAL")
 
 
+def skewness_from_skew(col: ColumnOrName) -> Column:
+    return Column.invoke_anonymous_function(col, "SKEW")
+
+
 def isnan_using_equal(col: ColumnOrName) -> Column:
     lit = get_func_from_session("lit")
     return Column(
@@ -219,6 +228,30 @@ def percentile_approx_without_accuracy_and_plural(
     return Column(make_bracket_approx_percentile(percentage))  # type: ignore
 
 
+def percentile_approx_without_accuracy_and_max_array(
+    col: ColumnOrName,
+    percentage: t.Union[ColumnOrLiteral, t.List[float], t.Tuple[float]],
+    accuracy: t.Optional[float] = None,
+) -> Column:
+    from sqlframe.base.functions import percentile_approx
+
+    lit = get_func_from_session("lit")
+    array = get_func_from_session("array")
+    col_func = get_func_from_session("col")
+
+    def make_approx_percentile(percentage: float) -> expression.Anonymous:
+        return expression.Anonymous(
+            this="APPROX_PERCENTILE",
+            expressions=[col_func(col).expression, lit(percentage).expression],
+        )
+
+    if accuracy:
+        logger.warning("Accuracy is ignored since it is not supported in this dialect")
+    if isinstance(percentage, (list, tuple)):
+        return array(*[make_approx_percentile(p) for p in percentage])
+    return percentile_approx(col, percentage)
+
+
 def percentile_without_disc(
     col: ColumnOrName,
     percentage: t.Union[ColumnOrLiteral, t.List[float], t.Tuple[float]],
@@ -258,6 +291,57 @@ def round_cast_as_numeric(col: ColumnOrName, scale: t.Optional[int] = None) -> C
     return round(col_func(col).cast("numeric"), scale)
 
 
+def bround_using_half_even(col: ColumnOrName, scale: t.Optional[int] = None) -> Column:
+    lit_func = get_func_from_session("lit")
+
+    return Column.invoke_anonymous_function(col, "ROUND", scale, lit_func("HALF_TO_EVEN"))  # type: ignore
+
+
+def shiftleft_from_bitshiftleft(col: ColumnOrName, numBits: int) -> Column:
+    col_func = get_func_from_session("col")
+    lit = get_func_from_session("lit")
+
+    return Column(
+        expression.Anonymous(
+            this="BITSHIFTLEFT",
+            expressions=[col_func(col).expression, lit(numBits).expression],
+        )
+    )
+
+
+def shiftright_from_bitshiftright(col: ColumnOrName, numBits: int) -> Column:
+    col_func = get_func_from_session("col")
+    lit = get_func_from_session("lit")
+
+    return Column(
+        expression.Anonymous(
+            this="BITSHIFTRIGHT",
+            expressions=[col_func(col).expression, lit(numBits).expression],
+        )
+    )
+
+
+def struct_with_eq(
+    col: t.Union[ColumnOrName, t.Iterable[ColumnOrName]], *cols: ColumnOrName
+) -> Column:
+    from sqlframe.base.session import _BaseSession
+
+    col_func = get_func_from_session("col")
+
+    columns = [col_func(x) for x in ensure_list(col) + list(cols)]
+    expressions = []
+    for column in columns:
+        expressions.append(
+            expression.PropertyEQ(
+                this=expression.parse_identifier(
+                    column.alias_or_name, dialect=_BaseSession().input_dialect
+                ),
+                expression=column.expression,
+            )
+        )
+    return Column(expression.Struct(expressions=expressions))
+
+
 def year_from_extract(col: ColumnOrName) -> Column:
     col_func = get_func_from_session("col")
 
@@ -421,6 +505,49 @@ def make_date_from_date_func(year: ColumnOrName, month: ColumnOrName, day: Colum
     )
 
 
+def make_date_date_from_parts(year: ColumnOrName, month: ColumnOrName, day: ColumnOrName) -> Column:
+    col_func = get_func_from_session("col")
+
+    return Column(
+        expression.Anonymous(
+            this="DATE_FROM_PARTS",
+            expressions=[
+                col_func(year).cast("integer").expression,
+                col_func(month).cast("integer").expression,
+                col_func(day).cast("integer").expression,
+            ],
+        )
+    )
+
+
+def date_add_no_date_sub(
+    col: ColumnOrName, days: t.Union[ColumnOrName, int], cast_as_date: bool = True
+) -> Column:
+    lit_func = get_func_from_session("col")
+
+    if isinstance(days, int):
+        days = lit_func(days)
+
+    result = Column.invoke_expression_over_column(
+        Column.ensure_col(col).cast("date"),
+        expression.DateAdd,
+        expression=days,
+        unit=expression.Var(this="DAY"),
+    )
+    if cast_as_date:
+        return result.cast("date")
+    return result
+
+
+def date_sub_by_date_add(
+    col: ColumnOrName, days: t.Union[ColumnOrName, int], cast_as_date: bool = True
+) -> Column:
+    lit_func = get_func_from_session("col")
+    date_add_func = get_func_from_session("date_add")
+
+    return date_add_func(col, days * lit_func(-1), cast_as_date)
+
+
 def to_date_from_timestamp(col: ColumnOrName, format: t.Optional[str] = None) -> Column:
     from sqlframe.base.functions import to_date
 
@@ -520,6 +647,31 @@ def add_months_by_multiplication(
     return value
 
 
+def add_months_using_func(
+    start: ColumnOrName, months: t.Union[ColumnOrName, int], cast_as_date: bool = True
+) -> Column:
+    from sqlframe.base.functions import add_months
+
+    if isinstance(months, int):
+        months = get_func_from_session("lit")(months)
+    else:
+        months = Column.ensure_col(months)
+
+    value = Column(
+        expression.Anonymous(
+            this="ADD_MONTHS",
+            expressions=[
+                Column.ensure_col(start).expression,
+                months.expression,  # type: ignore
+            ],
+        )
+    )
+
+    if cast_as_date:
+        return value.cast("date")
+    return value
+
+
 def months_between_from_age_and_extract(
     date1: ColumnOrName, date2: ColumnOrName, roundOff: t.Optional[bool] = None
 ) -> Column:
@@ -545,6 +697,23 @@ def months_between_from_age_and_extract(
     ).cast("bigint")
 
 
+def months_between_cast_as_date_cast_roundoff(
+    date1: ColumnOrName, date2: ColumnOrName, roundOff: t.Optional[bool] = None
+) -> Column:
+    from sqlframe.base.functions import months_between
+
+    col_func = get_func_from_session("col")
+
+    date1 = col_func(date1).cast("date")
+    date2 = col_func(date2).cast("date")
+
+    value = months_between(date1, date2)
+
+    if roundOff:
+        return value.cast("bigint")
+    return value
+
+
 def from_unixtime_from_timestamp(col: ColumnOrName, format: t.Optional[str] = None) -> Column:
     from sqlframe.base.session import _BaseSession
 
@@ -590,12 +759,30 @@ def bas64_from_encode(col: ColumnOrLiteral) -> Column:
     )
 
 
+def base64_from_base64_encode(col: ColumnOrLiteral) -> Column:
+    return Column(
+        expression.Anonymous(
+            this="BASE64_ENCODE",
+            expressions=[Column(col).expression],
+        )
+    )
+
+
 def unbase64_from_decode(col: ColumnOrLiteral) -> Column:
     return Column(
         expression.Decode(this=Column(col).expression, charset=expression.Literal.string("base64"))
     )
 
 
+def unbase64_from_base64_decode_string(col: ColumnOrLiteral) -> Column:
+    return Column(
+        expression.Anonymous(
+            this="BASE64_DECODE_STRING",
+            expressions=[Column(col).expression],
+        )
+    )
+
+
 def decode_from_blob(col: ColumnOrLiteral, charset: str) -> Column:
     return Column(
         expression.Decode(
@@ -716,6 +903,19 @@ def overlay_from_substr(
     )
 
 
+def levenshtein_edit_distance(
+    left: ColumnOrName, right: ColumnOrName, threshold: t.Optional[int] = None
+) -> Column:
+    if threshold is not None:
+        logger.warning("Threshold is ignored since it is not supported in this dialect")
+    return Column(
+        expression.Anonymous(
+            this="EDITDISTANCE",
+            expressions=[Column.ensure_col(left).expression, Column.ensure_col(right).expression],
+        )
+    )
+
+
 def split_no_limit(str: ColumnOrName, pattern: str, limit: t.Optional[int] = None) -> Column:
     from sqlframe.base.functions import split
 
@@ -758,6 +958,17 @@ def split_with_split(str: ColumnOrName, pattern: str, limit: t.Optional[int] = N
     )
 
 
+def regexp_extract_coalesce_empty_str(
+    str: ColumnOrName, pattern: str, idx: t.Optional[int] = None
+) -> Column:
+    from sqlframe.base.functions import regexp_extract
+
+    coalesce = get_func_from_session("coalesce")
+    lit_func = get_func_from_session("lit")
+
+    return coalesce(regexp_extract(str, pattern, idx), lit_func(""))
+
+
 def array_contains_any(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
     lit = get_func_from_session("lit")
     value_col = value if isinstance(value, Column) else lit(value)
@@ -830,6 +1041,16 @@ def slice_with_brackets(
     )
 
 
+def array_join_no_null_replacement(
+    col: ColumnOrName, delimiter: str, null_replacement: t.Optional[str] = None
+) -> Column:
+    from sqlframe.base.functions import array_join
+
+    if null_replacement is None:
+        logger.warning("Null replacement is ignored since it is not supported in this dialect")
+    return array_join(col, delimiter)
+
+
 def array_join_null_replacement_with_transform(
     col: ColumnOrName, delimiter: str, null_replacement: t.Optional[str] = None
 ) -> Column:
@@ -860,6 +1081,57 @@ def array_join_null_replacement_with_transform(
     return array_join(col, delimiter)
 
 
+def array_contains_cast_variant(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
+    from sqlframe.base.functions import array_contains
+
+    lit = get_func_from_session("lit")
+    value_col = value if isinstance(value, Column) else lit(value)
+    return array_contains(col, value_col.cast("variant"))
+
+
+def arrays_overlap_as_plural(col1: ColumnOrName, col2: ColumnOrName) -> Column:
+    col_func = get_func_from_session("col")
+
+    return Column(
+        expression.Anonymous(
+            this="ARRAYS_OVERLAP",
+            expressions=[col_func(col1).expression, col_func(col2).expression],
+        )
+    )
+
+
+def slice_as_array_slice(
+    x: ColumnOrName, start: t.Union[ColumnOrName, int], length: t.Union[ColumnOrName, int]
+) -> Column:
+    lit = get_func_from_session("lit")
+
+    start_col = start if isinstance(start, Column) else lit(start)
+    length_col = length if isinstance(length, Column) else lit(length)
+    return Column.invoke_anonymous_function(
+        x, "ARRAY_SLICE", start_col - lit(1), start_col + length_col
+    )
+
+
+def array_position_cast_variant_and_flip(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
+    when = get_func_from_session("when")
+    lit = get_func_from_session("lit")
+    value_col = value if isinstance(value, Column) else lit(value)
+    # Some engines return NULL if item is not found but Spark expects 0 so we coalesce to 0
+    resp = Column.invoke_anonymous_function(value_col.cast("variant"), "ARRAY_POSITION", col)
+    return when(resp.isNotNull(), resp + lit(1)).otherwise(lit(0))
+
+
+def array_intersect_using_intersection(col1: ColumnOrName, col2: ColumnOrName) -> Column:
+    col_func = get_func_from_session("col")
+
+    return Column(
+        expression.Anonymous(
+            this="ARRAY_INTERSECTION",
+            expressions=[col_func(col1).expression, col_func(col2).expression],
+        )
+    )
+
+
 def element_at_using_brackets(col: ColumnOrName, value: ColumnOrLiteral) -> Column:
     col_func = get_func_from_session("col")
     lit = get_func_from_session("lit")
@@ -936,6 +1208,25 @@ def get_json_object_using_arrow_op(col: ColumnOrName, path: str) -> Column:
     )
 
 
+def get_json_object_cast_object(col: ColumnOrName, path: str) -> Column:
+    from sqlframe.base.functions import get_json_object
+
+    col_func = get_func_from_session("col")
+
+    return get_json_object(col_func(col).cast("variant"), path)
+
+
+def create_map_with_cast(*cols: t.Union[ColumnOrName, t.Iterable[ColumnOrName]]) -> Column:
+    from sqlframe.base.functions import create_map
+
+    col = get_func_from_session("col")
+
+    columns = list(_flatten(cols)) if not isinstance(cols[0], (str, Column)) else cols
+    col1_dtype = col(columns[0]).dtype or "VARCHAR"
+    col2_dtype = col(columns[1]).dtype or "VARCHAR"
+    return create_map(*cols).cast(f"MAP({col1_dtype}, {col2_dtype})")
+
+
 def array_min_from_sort(col: ColumnOrName) -> Column:
     element_at = get_func_from_session("element_at")
     array_sort = get_func_from_session("array_sort")
@@ -992,6 +1283,43 @@ def array_max_from_subquery(col: ColumnOrName) -> Column:
     return Column(expression.Subquery(this=select)).alias(col_func(col).alias_or_name)
 
 
+def sort_array_using_array_sort(col: ColumnOrName, asc: t.Optional[bool] = None) -> Column:
+    col_func = get_func_from_session("col")
+    lit_func = get_func_from_session("lit")
+    expressions = [col_func(col).expression]
+    asc = asc if asc is not None else True
+    expressions.append(lit_func(asc).expression)
+    if asc:
+        expressions.append(lit_func(True).expression)
+    else:
+        expressions.append(lit_func(False).expression)
+
+    return Column(
+        expression.Anonymous(
+            this="ARRAY_SORT",
+            expressions=expressions,
+        )
+    )
+
+
+def flatten_using_array_flatten(col: ColumnOrName) -> Column:
+    col_func = get_func_from_session("col")
+
+    return Column(
+        expression.Anonymous(
+            this="ARRAY_FLATTEN",
+            expressions=[col_func(col).expression],
+        )
+    )
+
+
+def map_concat_using_map_cat(*cols: t.Union[ColumnOrName, t.Iterable[ColumnOrName]]) -> Column:
+    columns = list(flatten(cols)) if not isinstance(cols[0], (str, Column)) else cols  # type: ignore
+    if len(columns) == 1:
+        return Column.invoke_anonymous_function(columns[0], "MAP_CAT")
+    return Column.invoke_anonymous_function(columns[0], "MAP_CAT", *columns[1:])
+
+
 def sequence_from_generate_series(
     start: ColumnOrName, stop: ColumnOrName, step: t.Optional[ColumnOrName] = None
 ) -> Column:
@@ -1026,6 +1354,27 @@ def sequence_from_generate_array(
     )
 
 
+def sequence_from_array_generate_range(
+    start: ColumnOrName, stop: ColumnOrName, step: t.Optional[ColumnOrName] = None
+) -> Column:
+    col_func = get_func_from_session("col")
+    when = get_func_from_session("when")
+    lit = get_func_from_session("lit")
+
+    return Column(
+        expression.Anonymous(
+            this="ARRAY_GENERATE_RANGE",
+            expressions=[
+                col_func(start).expression,
+                (
+                    col_func(stop) + when(col_func(stop) > lit(0), lit(1)).otherwise(lit(-1))
+                ).expression,
+                col_func(step).expression if step else lit(1).expression,
+            ],
+        )
+    )
+
+
 def regexp_extract_only_one_group(
     str: ColumnOrName, pattern: str, idx: t.Optional[int] = None
 ) -> Column:
@@ -1048,6 +1397,28 @@ def hex_casted_as_bytes(col: ColumnOrName) -> Column:
     )
 
 
+def hex_using_encode(col: ColumnOrName) -> Column:
+    col_func = get_func_from_session("col")
+
+    return Column(
+        expression.Anonymous(
+            this="HEX_ENCODE",
+            expressions=[col_func(col).expression],
+        )
+    )
+
+
+def unhex_hex_decode_str(col: ColumnOrName) -> Column:
+    col_func = get_func_from_session("col")
+
+    return Column(
+        expression.Anonymous(
+            this="HEX_DECODE_STRING",
+            expressions=[col_func(col).expression],
+        )
+    )
+
+
 def bit_length_from_length(col: ColumnOrName) -> Column:
     lit = get_func_from_session("lit")
     col_func = get_func_from_session("col")

sqlframe/base/functions.py

@@ -222,7 +222,7 @@ def cot(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "COT")
 
 
-@meta(unsupported_engines=["duckdb", "postgres"])
+@meta(unsupported_engines=["duckdb", "postgres", "snowflake"])
 def csc(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "CSC")
 
@@ -281,7 +281,7 @@ def rint(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "RINT")
 
 
-@meta(unsupported_engines=["duckdb", "postgres"])
+@meta(unsupported_engines=["duckdb", "postgres", "snowflake"])
 def sec(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "SEC")
 
@@ -407,7 +407,7 @@ def collect_set(col: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col, expression.ArrayUniqueAgg)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def hypot(col1: t.Union[ColumnOrName, float], col2: t.Union[ColumnOrName, float]) -> Column:
     col1_value = lit(col1) if isinstance(col1, (int, float)) else col1
     col2_value = lit(col2) if isinstance(col2, (int, float)) else col2
@@ -482,7 +482,7 @@ def covar_samp(col1: ColumnOrName, col2: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col1, expression.CovarSamp, expression=col2)
 
 
-@meta(unsupported_engines=["bigquery", "postgres"])
+@meta(unsupported_engines=["bigquery", "postgres", "snowflake"])
 def first(col: ColumnOrName, ignorenulls: t.Optional[bool] = None) -> Column:
     this = Column.invoke_expression_over_column(col, expression.First)
     if ignorenulls:
@@ -516,7 +516,7 @@ def isnull(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "ISNULL")
 
 
-@meta(unsupported_engines=["bigquery", "postgres"])
+@meta(unsupported_engines=["bigquery", "postgres", "snowflake"])
 def last(col: ColumnOrName, ignorenulls: t.Optional[bool] = None) -> Column:
     this = Column.invoke_expression_over_column(col, expression.Last)
     if ignorenulls:
@@ -569,7 +569,7 @@ def rand(seed: t.Optional[int] = None) -> Column:
     return Column.invoke_expression_over_column(None, expression.Rand)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def randn(seed: t.Optional[int] = None) -> Column:
     if seed is not None:
         return Column.invoke_expression_over_column(None, expression.Randn, this=lit(seed))
@@ -610,7 +610,7 @@ def shiftright(col: ColumnOrName, numBits: int) -> Column:
 shiftRight = shiftright
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def shiftrightunsigned(col: ColumnOrName, numBits: int) -> Column:
     return Column.invoke_anonymous_function(
         Column.ensure_col(col).cast("bigint"), "SHIFTRIGHTUNSIGNED", lit(numBits)
@@ -631,7 +631,7 @@ def struct(col: t.Union[ColumnOrName, t.Iterable[ColumnOrName]], *cols: ColumnOr
     return Column.invoke_expression_over_column(None, expression.Struct, expressions=columns)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def conv(col: ColumnOrName, fromBase: int, toBase: int) -> Column:
     return Column.invoke_anonymous_function(col, "CONV", lit(fromBase), lit(toBase))
 
@@ -976,7 +976,7 @@ def session_window(timeColumn: ColumnOrName, gapDuration: ColumnOrName) -> Colum
     return Column.invoke_anonymous_function(timeColumn, "SESSION_WINDOW", gap_duration_column)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def crc32(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "CRC32")
 
@@ -1002,7 +1002,7 @@ def hash(*cols: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(cols[0], "HASH", *args)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def xxhash64(*cols: ColumnOrName) -> Column:
     args = cols[1:] if len(cols) > 1 else []
     return Column.invoke_anonymous_function(cols[0], "XXHASH64", *args)
@@ -1069,14 +1069,14 @@ def concat_ws(sep: str, *cols: ColumnOrName) -> Column:
     )
 
 
-@meta(unsupported_engines="bigquery")
+@meta(unsupported_engines=["bigquery", "snowflake"])
 def decode(col: ColumnOrName, charset: str) -> Column:
     return Column.invoke_expression_over_column(
         col, expression.Decode, charset=expression.Literal.string(charset)
     )
 
 
-@meta(unsupported_engines="bigquery")
+@meta(unsupported_engines=["bigquery", "snowflake"])
 def encode(col: ColumnOrName, charset: str) -> Column:
     return Column.invoke_expression_over_column(
         col, expression.Encode, charset=expression.Literal.string(charset)
@@ -1088,7 +1088,7 @@ def format_number(col: ColumnOrName, d: int) -> Column:
     return Column.invoke_anonymous_function(col, "FORMAT_NUMBER", lit(d))
 
 
-@meta()
+@meta(unsupported_engines="snowflake")
 def format_string(format: str, *cols: ColumnOrName) -> Column:
     format_col = lit(format)
     columns = [Column.ensure_col(x) for x in cols]
@@ -1114,7 +1114,7 @@ def overlay(
     return Column.invoke_anonymous_function(src, "OVERLAY", replace, pos_value)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def sentences(
     string: ColumnOrName,
     language: t.Optional[ColumnOrName] = None,
@@ -1134,7 +1134,7 @@ def substring(str: ColumnOrName, pos: int, len: int) -> Column:
     return Column.ensure_col(str).substr(pos, len)
 
 
-@meta(unsupported_engines=["duckdb", "postgres"])
+@meta(unsupported_engines=["duckdb", "postgres", "snowflake"])
 def substring_index(str: ColumnOrName, delim: str, count: int) -> Column:
     return Column.invoke_anonymous_function(str, "SUBSTRING_INDEX", lit(delim), lit(count))
 
@@ -1236,7 +1236,7 @@ def soundex(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "SOUNDEX")
 
 
-@meta(unsupported_engines="postgres")
+@meta(unsupported_engines=["postgres", "snowflake"])
 def bin(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "BIN")
 
@@ -1288,7 +1288,7 @@ def create_map(*cols: t.Union[ColumnOrName, t.Iterable[ColumnOrName]]) -> Column
     )
 
 
-@meta(unsupported_engines=["bigquery", "postgres"])
+@meta(unsupported_engines=["bigquery", "postgres", "snowflake"])
 def map_from_arrays(col1: ColumnOrName, col2: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(None, expression.Map, keys=col1, values=col2)
 
@@ -1382,27 +1382,28 @@ def posexplode(col: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col, expression.Posexplode)
 
 
-@meta(unsupported_engines=["duckdb", "postgres"])
+@meta(unsupported_engines=["duckdb", "postgres", "snowflake"])
 def explode_outer(col: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col, expression.ExplodeOuter)
 
 
-@meta(unsupported_engines=["duckdb", "postgres"])
+@meta(unsupported_engines=["duckdb", "postgres", "snowflake"])
 def posexplode_outer(col: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col, expression.PosexplodeOuter)
 
 
-@meta()
+# Snowflake doesn't support JSONPath which is what this function uses
+@meta(unsupported_engines="snowflake")
 def get_json_object(col: ColumnOrName, path: str) -> Column:
     return Column.invoke_expression_over_column(col, expression.JSONExtract, expression=lit(path))
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def json_tuple(col: ColumnOrName, *fields: str) -> Column:
     return Column.invoke_anonymous_function(col, "JSON_TUPLE", *[lit(field) for field in fields])
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def from_json(
     col: ColumnOrName,
     schema: t.Union[ArrayType, StructType, Column, str],
@@ -1419,7 +1420,7 @@ def from_json(
     return Column.invoke_anonymous_function(col, "FROM_JSON", schema)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def to_json(col: ColumnOrName, options: t.Optional[t.Dict[str, str]] = None) -> Column:
     if options is not None:
         options_col = create_map([lit(x) for x in _flatten(options.items())])
@@ -1443,7 +1444,7 @@ def schema_of_csv(col: ColumnOrName, options: t.Optional[t.Dict[str, str]] = Non
     return Column.invoke_anonymous_function(col, "SCHEMA_OF_CSV")
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def to_csv(col: ColumnOrName, options: t.Optional[t.Dict[str, str]] = None) -> Column:
     if options is not None:
         options_col = create_map([lit(x) for x in _flatten(options.items())])
@@ -1486,12 +1487,12 @@ def array_sort(
     return Column.invoke_expression_over_column(col, expression.ArraySort)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def shuffle(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "SHUFFLE")
 
 
-@meta()
+@meta(unsupported_engines="snowflake")
 def reverse(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "REVERSE")
 
@@ -1506,28 +1507,28 @@ def map_keys(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "MAP_KEYS")
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def map_values(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "MAP_VALUES")
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def map_entries(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "MAP_ENTRIES")
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def map_from_entries(col: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col, expression.MapFromEntries)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def array_repeat(col: ColumnOrName, count: t.Union[ColumnOrName, int]) -> Column:
     count_col = count if isinstance(count, Column) else lit(count)
     return Column.invoke_anonymous_function(col, "ARRAY_REPEAT", count_col)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def arrays_zip(*cols: ColumnOrName) -> Column:
     if len(cols) == 1:
         return Column.invoke_anonymous_function(cols[0], "ARRAYS_ZIP")
@@ -1551,7 +1552,7 @@ def sequence(
     return Column.invoke_anonymous_function(start, "SEQUENCE", stop)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def from_csv(
     col: ColumnOrName,
     schema: t.Union[Column, str],
@@ -1564,7 +1565,7 @@ def from_csv(
     return Column.invoke_anonymous_function(col, "FROM_CSV", schema)
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def aggregate(
     col: ColumnOrName,
     initialValue: ColumnOrName,
@@ -1586,7 +1587,7 @@ def aggregate(
     )
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def transform(
     col: ColumnOrName,
     f: t.Union[t.Callable[[Column], Column], t.Callable[[Column, Column], Column]],
@@ -1597,19 +1598,19 @@ def transform(
     )
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def exists(col: ColumnOrName, f: t.Callable[[Column], Column]) -> Column:
     f_expression = _get_lambda_from_func(f)
     return Column.invoke_anonymous_function(col, "EXISTS", Column(f_expression))
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def forall(col: ColumnOrName, f: t.Callable[[Column], Column]) -> Column:
     f_expression = _get_lambda_from_func(f)
     return Column.invoke_anonymous_function(col, "FORALL", Column(f_expression))
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def filter(
     col: ColumnOrName,
     f: t.Union[t.Callable[[Column], Column], t.Callable[[Column, Column], Column]],
@@ -1620,7 +1621,7 @@ def filter(
     )
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def zip_with(
     left: ColumnOrName, right: ColumnOrName, f: t.Callable[[Column, Column], Column]
 ) -> Column:
@@ -1628,25 +1629,25 @@ def zip_with(
     return Column.invoke_anonymous_function(left, "ZIP_WITH", right, Column(f_expression))
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def transform_keys(col: ColumnOrName, f: t.Union[t.Callable[[Column, Column], Column]]) -> Column:
     f_expression = _get_lambda_from_func(f)
     return Column.invoke_anonymous_function(col, "TRANSFORM_KEYS", Column(f_expression))
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def transform_values(col: ColumnOrName, f: t.Union[t.Callable[[Column, Column], Column]]) -> Column:
     f_expression = _get_lambda_from_func(f)
     return Column.invoke_anonymous_function(col, "TRANSFORM_VALUES", Column(f_expression))
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def map_filter(col: ColumnOrName, f: t.Union[t.Callable[[Column, Column], Column]]) -> Column:
     f_expression = _get_lambda_from_func(f)
     return Column.invoke_anonymous_function(col, "MAP_FILTER", Column(f_expression))
 
 
-@meta(unsupported_engines=["bigquery", "duckdb", "postgres"])
+@meta(unsupported_engines=["bigquery", "duckdb", "postgres", "snowflake"])
 def map_zip_with(
     col1: ColumnOrName,
     col2: ColumnOrName,
@@ -1656,11 +1657,16 @@ def map_zip_with(
     return Column.invoke_anonymous_function(col1, "MAP_ZIP_WITH", col2, Column(f_expression))
 
 
-@meta(unsupported_engines="postgres")
+@meta(unsupported_engines=["postgres", "snowflake"])
 def typeof(col: ColumnOrName) -> Column:
     return Column.invoke_anonymous_function(col, "TYPEOF")
 
 
+@meta()
+def nullif(col1: ColumnOrName, col2: ColumnOrName) -> Column:
+    return Column.invoke_expression_over_column(col1, expression.Nullif, expression=col2)
+
+
 @meta()
 def _lambda_quoted(value: str) -> t.Optional[bool]:
     return False if value == "_" else None

sqlframe/base/normalize.py

@@ -65,6 +65,15 @@ def replace_branch_and_sequence_ids_with_cte_name(
                 return
 
 
+def normalize_dict(session: SESSION, data: t.Dict) -> t.Dict:
+    if isinstance(data, dict):
+        return {session._normalize_string(k): normalize_dict(session, v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [normalize_dict(session, v) for v in data]
+    else:
+        return data
+
+
 def _set_alias_name(id: exp.Identifier, name: str):
     id.set("this", name)
     id.set("quoted", False)

sqlframe/base/session.py

@@ -23,6 +23,7 @@ from sqlglot.schema import MappingSchema
 
 from sqlframe.base.catalog import _BaseCatalog
 from sqlframe.base.dataframe import _BaseDataFrame
+from sqlframe.base.normalize import normalize_dict
 from sqlframe.base.readerwriter import _BaseDataFrameReader, _BaseDataFrameWriter
 from sqlframe.base.util import (
     get_column_mapping_from_schema_input,
@@ -257,6 +258,7 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, CONN]):
             if isinstance(sample_row, Row):
                 sample_row = sample_row.asDict()
             if isinstance(sample_row, dict):
+                sample_row = normalize_dict(self, sample_row)
                 default_data_type = get_default_data_type(sample_row[name])
                 updated_mapping[name] = (
                     exp.DataType.build(default_data_type, dialect="spark")

sqlframe/snowflake/functions.py

@@ -15,4 +15,49 @@ globals().update(
 )
 
 
-from sqlframe.base.function_alternatives import e_literal as e  # noqa
+from sqlframe.base.function_alternatives import (  # noqa
+    e_literal as e,
+    expm1_from_exp as expm1,
+    log1p_from_log as log1p,
+    rint_from_round as rint,
+    bitwise_not_from_bitnot as bitwise_not,
+    skewness_from_skew as skewness,
+    isnan_using_equal as isnan,
+    isnull_using_equal as isnull,
+    nanvl_as_case as nanvl,
+    percentile_approx_without_accuracy_and_max_array as percentile_approx,
+    bround_using_half_even as bround,
+    shiftleft_from_bitshiftleft as shiftleft,
+    shiftright_from_bitshiftright as shiftright,
+    struct_with_eq as struct,
+    make_date_date_from_parts as make_date,
+    date_add_no_date_sub as date_add,
+    date_sub_by_date_add as date_sub,
+    add_months_using_func as add_months,
+    months_between_cast_as_date_cast_roundoff as months_between,
+    last_day_with_cast as last_day,
+    from_unixtime_from_timestamp as from_unixtime,
+    unix_timestamp_from_extract as unix_timestamp,
+    base64_from_base64_encode as base64,
+    unbase64_from_base64_decode_string as unbase64,
+    format_number_from_to_char as format_number,
+    overlay_from_substr as overlay,
+    levenshtein_edit_distance as levenshtein,
+    split_with_split as split,
+    regexp_extract_coalesce_empty_str as regexp_extract,
+    hex_using_encode as hex,
+    unhex_hex_decode_str as unhex,
+    create_map_with_cast as create_map,
+    array_contains_cast_variant as array_contains,
+    arrays_overlap_as_plural as arrays_overlap,
+    slice_as_array_slice as slice,
+    array_join_no_null_replacement as array_join,
+    array_position_cast_variant_and_flip as array_position,
+    element_at_using_brackets as element_at,
+    array_intersect_using_intersection as array_intersect,
+    array_union_using_array_concat as array_union,
+    sort_array_using_array_sort as sort_array,
+    flatten_using_array_flatten as flatten,
+    map_concat_using_map_cat as map_concat,
+    sequence_from_array_generate_range as sequence,
+)

sqlframe/snowflake/session.py

@@ -24,9 +24,17 @@ else:
 
 
 class JsonLoadsSnowflakeConverter(SnowflakeConverter):
+    # This might not be needed once proper arrow types are supported.
+    # Checkout this PR: https://github.com/snowflakedb/snowflake-connector-python/pull/1853/files
+    # Specifically see if `alter session set enable_structured_types_in_client_response=true` and
+    # `alter session set force_enable_structured_types_native_arrow_format=true` are supported then it might work.
+    # At the time of writing these were not supported parameters on my version on Snowflake.
     def _json_loads(self, ctx: dict[str, t.Any]) -> t.Callable:
         def conv(value: str) -> t.List:
-            return json.loads(value)
+            # Snowflake returns "undefined" for null values when inside an array
+            # We check if we replaced "'undefined'" string and if so we switch it back
+            # this is a lazy approach compared to writing a proper regex replace
+            return json.loads(value.replace("undefined", "null").replace("'null'", "undefined"))
 
         return conv
 
@@ -49,10 +57,9 @@ class SnowflakeSession(
     _writer = SnowflakeDataFrameWriter
     _df = SnowflakeDataFrame
 
+    DEFAULT_TIME_FORMAT = "YYYY-MM-DD HH:MI:SS"
+
     def __init__(self, conn: t.Optional[SnowflakeConnection] = None):
-        warnings.warn(
-            "SnowflakeSession is still in active development. Functions may not work as expected."
-        )
         import snowflake
 
         snowflake.connector.cursor.CAN_USE_ARROW_RESULT_FORMAT = False

{sqlframe-1.4.0.dist-info → sqlframe-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 1.4.0
+Version: 1.5.1
 Summary: Taking the Spark out of PySpark by converting to SQL
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman
@@ -18,7 +18,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: prettytable (<3.11.0)
-Requires-Dist: sqlglot (<24.1,>=24.0.0)
+Requires-Dist: sqlglot (<24.2,>=24.0.0)
 Provides-Extra: bigquery
 Requires-Dist: google-cloud-bigquery-storage (<3,>=2) ; extra == 'bigquery'
 Requires-Dist: google-cloud-bigquery[pandas] (<4,>=3) ; extra == 'bigquery'
@@ -72,6 +72,7 @@ SQLFrame currently supports the following engines (many more in development):
 * [BigQuery](https://sqlframe.readthedocs.io/en/stable/bigquery/)
 * [DuckDB](https://sqlframe.readthedocs.io/en/stable/duckdb)
 * [Postgres](https://sqlframe.readthedocs.io/en/stable/postgres)
+* [Snowflake](https://sqlframe.readthedocs.io/en/stable/snowflake)
 
 SQLFrame also has a "Standalone" session that be used to generate SQL without any connection to a database engine.
 * [Standalone](https://sqlframe.readthedocs.io/en/stable/standalone)
@@ -91,6 +92,8 @@ pip install "sqlframe[bigquery]"
 pip install "sqlframe[duckdb]"
 # Postgres
 pip install "sqlframe[postgres]"
+# Snowflake
+pip install "sqlframe[snowflake]"
 # Standalone
 pip install sqlframe
 ```

{sqlframe-1.4.0.dist-info → sqlframe-1.5.1.dist-info}/RECORD

@@ -1,19 +1,19 @@
 sqlframe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlframe/_version.py,sha256=R8-T9fmURjcuoxYpHTAjyNAhgJPDtI2jogCjqYYkfCU,411
+sqlframe/_version.py,sha256=W6YuN1JOd6M-rSt9HDXK91AutRDYXTjJT_LQg3rCsjk,411
 sqlframe/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlframe/base/_typing.py,sha256=DuTay8-o9W-pw3RPZCgLunKNJLS9PkaV11G_pxXp9NY,1256
 sqlframe/base/catalog.py,sha256=ATDGirouUjal05P4ymL-wIi8rgjg_8w4PoACamiO64A,37245
-sqlframe/base/column.py,sha256=p3VrtATBmjAYHollFcsdps2UJTNC-Pvyg4Zt7y4CK9w,15358
+sqlframe/base/column.py,sha256=kNp8Hfeozgs-OuZBky8-kvRq5uuRMAkkiLpb3fs4XUE,15575
 sqlframe/base/dataframe.py,sha256=9PuqC9dBficSE-Y1v_BHyk4gK-Hd43SaVBmxBeyNnD8,62939
 sqlframe/base/decorators.py,sha256=I5osMgx9BuCgbtp4jVM2DNwYJVLzCv-OtTedhQEik0g,1882
 sqlframe/base/exceptions.py,sha256=pCB9hXX4jxZWzNg3JN1i38cv3BmpUlee5NoLYx3YXIQ,208
-sqlframe/base/function_alternatives.py,sha256=to0kv3MTJmQFeVTMcitz0AxBIoUJC3cu5LkEY5aJpoo,31318
-sqlframe/base/functions.py,sha256=iVe8AbXGX_gXnkQ1N-clX6rihsonfzJ84_YvWzhB2FM,53540
+sqlframe/base/function_alternatives.py,sha256=NDXs2igY7PBsStzTSRZvJcCshBOJkPQl2GbhpVFU6To,42931
+sqlframe/base/functions.py,sha256=QgVMWnZFClxfbiOV4CpILtOtdo7-Ey5wWTehdGy0qkA,54393
 sqlframe/base/group.py,sha256=TES9CleVmH3x-0X-tqmuUKfCKSWjH5vg1aU3R6dDmFc,4059
-sqlframe/base/normalize.py,sha256=gRBn-PziFdE-CHtPJMkMl7y_YH0mauUcD4zfgyyvlpw,3565
+sqlframe/base/normalize.py,sha256=nXAJ5CwxVf4DV0GsH-q1w0p8gmjSMlv96k_ez1eVul8,3880
 sqlframe/base/operations.py,sha256=-AhNuEzcV7ZExoP1oY3blaKip-joQyJeQVvfBTs_2g4,3456
 sqlframe/base/readerwriter.py,sha256=5NPQMiOrw6I54U243R_6-ynnWYsNksgqwRpPp4IFjIw,25288
-sqlframe/base/session.py,sha256=-h7qcOPRw9KBJPg_V6Tlr8Z2SmcsgAWruBo34o6zfrQ,21795
+sqlframe/base/session.py,sha256=EhQb2oVRApU_xcbdVc5m0WrwKAbDjcUCRLAVzcg_JH8,21908
 sqlframe/base/transforms.py,sha256=y0j3SGDz3XCmNGrvassk1S-owllUWfkHyMgZlY6SFO4,467
 sqlframe/base/types.py,sha256=aJT5YXr-M_LAfUM0uK4asfbrQFab_xmsp1CP2zkG8p0,11924
 sqlframe/base/util.py,sha256=wdATi7STt-FfXrX9TPRkw4PFJP7uAsK_K9YkKSrd0qU,8824
@@ -66,10 +66,10 @@ sqlframe/snowflake/__init__.py,sha256=nuQ3cuHjDpW4ELZfbd2qOYmtXmcYl7MtsrdOrRdozo
 sqlframe/snowflake/catalog.py,sha256=uDjBgDdCyxaDkGNX_8tb-lol7MwwazcClUBAZsOSj70,5014
 sqlframe/snowflake/column.py,sha256=E1tUa62Y5HajkhgFuebU9zohrGyieudcHzTT8gfalio,40
 sqlframe/snowflake/dataframe.py,sha256=OJ27NudBUE3XX9mc8ywooGhYV4ijF9nX2K_nkHRcTx4,1393
-sqlframe/snowflake/functions.py,sha256=ZYX9gyPvmpKoLi_7uQdB0uPQNTREOAJD0aCcccX1iPc,456
+sqlframe/snowflake/functions.py,sha256=HXxt-wM05vcbgmu06uGApGd-Z9bWOwWwjqPfg38fF0M,2330
 sqlframe/snowflake/group.py,sha256=pPP1l2RRo_LgkXrji8a87n2PKo-63ZRPT-WUtvVcBME,395
 sqlframe/snowflake/readwriter.py,sha256=yhRc2HcMq6PwV3ghZWC-q-qaE7LE4aEjZEXCip4OOlQ,884
-sqlframe/snowflake/session.py,sha256=QKdxXgK9_YgxoyxzEd73ot4t0M6Dz4em09JdVMYxVPI,2584
+sqlframe/snowflake/session.py,sha256=bDOlnuIiQ9j_zfF7F5H1gTLmpHUjruIxr2CfXcS_7YU,3284
 sqlframe/snowflake/types.py,sha256=KwNyuXIo-2xVVd4bZED3YrQOobKCtemlxGrJL7DrTC8,34
 sqlframe/snowflake/window.py,sha256=6GKPzuxeSapJakBaKBeT9VpED1ACdjggDv9JRILDyV0,35
 sqlframe/spark/__init__.py,sha256=jamKYQtQaKjjXnQ01QGPHvatbrZSw9sWno_VOUGSz6I,712
@@ -92,8 +92,8 @@ sqlframe/standalone/readwriter.py,sha256=EZNyDJ4ID6sGNog3uP4-e9RvchX4biJJDNtc5hk
 sqlframe/standalone/session.py,sha256=wQmdu2sv6KMTAv0LRFk7TY7yzlh3xvmsyqilEtRecbY,1191
 sqlframe/standalone/types.py,sha256=KwNyuXIo-2xVVd4bZED3YrQOobKCtemlxGrJL7DrTC8,34
 sqlframe/standalone/window.py,sha256=6GKPzuxeSapJakBaKBeT9VpED1ACdjggDv9JRILDyV0,35
-sqlframe-1.4.0.dist-info/LICENSE,sha256=VZu79YgW780qxaFJMr0t5ZgbOYEh04xWoxaWOaqIGWk,1068
-sqlframe-1.4.0.dist-info/METADATA,sha256=nnz73ML6w8WyctFzwiaKVVNr9RQwmpmfckrcKqEX_PE,7219
-sqlframe-1.4.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-sqlframe-1.4.0.dist-info/top_level.txt,sha256=T0_RpoygaZSF6heeWwIDQgaP0varUdSK1pzjeJZRjM8,9
-sqlframe-1.4.0.dist-info/RECORD,,
+sqlframe-1.5.1.dist-info/LICENSE,sha256=VZu79YgW780qxaFJMr0t5ZgbOYEh04xWoxaWOaqIGWk,1068
+sqlframe-1.5.1.dist-info/METADATA,sha256=dHIN2Vu-zGlN7rNFnbeJt3oy_ZajB9Y63pQgmi-NK_w,7332
+sqlframe-1.5.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+sqlframe-1.5.1.dist-info/top_level.txt,sha256=T0_RpoygaZSF6heeWwIDQgaP0varUdSK1pzjeJZRjM8,9
+sqlframe-1.5.1.dist-info/RECORD,,