sqlframe 3.21.0__tar.gz → 3.22.0__tar.gz

{sqlframe-3.21.0 → sqlframe-3.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 3.21.0
+Version: 3.22.0
 Summary: Turning PySpark Into a Universal DataFrame API
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman

{sqlframe-3.21.0 → sqlframe-3.22.0}/docs/duckdb.md

@@ -406,6 +406,7 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [min](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.min.html)
 * [min_by](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.min_by.html)
 * [minute](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.minute.html)
+* [mode](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.mode.html)
 * [month](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.month.html)
 * [months_between](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.months_between.html)
     * Rounded whole number is returned
@@ -448,7 +449,6 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [sin](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.sin.html)
 * [size](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.size.html)
 * [skewness](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.skewness.html)
-    * Returned value is different but is still calculating the same thing. Need to investigate difference in calculation
 * [slice](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.slice.html)
 * [sort_array](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.sort_array.html)
 * [soundex](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.soundex.html)

{sqlframe-3.21.0 → sqlframe-3.22.0}/docs/snowflake.md

@@ -439,6 +439,7 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [min](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.min.html)
 * [min_by](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.min_by.html)
 * [minute](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.minute.html)
+* [mode](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.mode.html)
 * [module](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.module.html)
 * [month](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.month.html)
 * [months_between](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.months_between.html)
@@ -487,7 +488,6 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [sinh](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.sinh.html)
 * [size](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.size.html)
 * [skewness](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.skewness.html)
-  * Skewness is calculated differently
 * [slice](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.slice.html)
 * [sort_array](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.sort_array.html)
 * [soundex](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.soundex.html)

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.21.0'
-__version_tuple__ = version_tuple = (3, 21, 0)
+__version__ = version = '3.22.0'
+__version_tuple__ = version_tuple = (3, 22, 0)

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/base/dataframe.py

@@ -296,6 +296,12 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
 
     @property
     def columns(self) -> t.List[str]:
+        expression_display_names = self.expression.copy()
+        self._set_display_names(expression_display_names)
+        return expression_display_names.named_selects
+
+    @property
+    def _columns(self) -> t.List[str]:
         return self.expression.named_selects
 
     @property
@@ -336,7 +342,7 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
             return types.StructType(
                 [
                     types.StructField(
-                        c.name,
+                        self.display_name_mapping.get(c.name, c.name),
                         sqlglot_to_spark(
                             exp.DataType.build(c.dataType, dialect=self.session.output_dialect)
                         ),
@@ -611,6 +617,18 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         }
         self.display_name_mapping.update(zipped)
 
+    def _set_display_names(self, select_expression: exp.Select) -> None:
+        for index, column in enumerate(select_expression.expressions):
+            column_name = quote_preserving_alias_or_name(column)
+            if column_name in self.display_name_mapping:
+                display_name_identifier = exp.to_identifier(
+                    self.display_name_mapping[column_name], quoted=True
+                )
+                display_name_identifier._meta = {"case_sensitive": True, **(column._meta or {})}
+                select_expression.expressions[index] = exp.alias_(
+                    column.unalias(), display_name_identifier, quoted=True
+                )
+
     def _get_expressions(
         self,
         optimize: bool = True,
@@ -631,16 +649,7 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
             select_expression = select_expression.transform(
                 replace_id_value, replacement_mapping
             ).assert_is(exp.Select)
-            for index, column in enumerate(select_expression.expressions):
-                column_name = quote_preserving_alias_or_name(column)
-                if column_name in self.display_name_mapping:
-                    display_name_identifier = exp.to_identifier(
-                        self.display_name_mapping[column_name], quoted=True
-                    )
-                    display_name_identifier._meta = {"case_sensitive": True, **(column._meta or {})}
-                    select_expression.expressions[index] = exp.alias_(
-                        column.unalias(), display_name_identifier, quoted=True
-                    )
+            self._set_display_names(select_expression)
             if optimize:
                 select_expression = t.cast(
                     exp.Select,
@@ -1158,8 +1167,8 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
 
     @operation(Operation.FROM)
     def unionByName(self, other: Self, allowMissingColumns: bool = False) -> Self:
-        l_columns = self.columns
-        r_columns = other.columns
+        l_columns = self._columns
+        r_columns = other._columns
         if not allowMissingColumns:
             l_expressions = l_columns
             r_expressions = l_columns
@@ -1619,9 +1628,9 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         | 16|  Bob|
         +---+-----+
         """
-        if len(cols) != len(self.columns):
+        if len(cols) != len(self._columns):
             raise ValueError(
-                f"Number of column names does not match number of columns: {len(cols)} != {len(self.columns)}"
+                f"Number of column names does not match number of columns: {len(cols)} != {len(self._columns)}"
             )
         expression = self.expression.copy()
         expression = expression.select(
@@ -1889,7 +1898,7 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         print("root")
         for column in self._typed_columns:
             print_schema(
-                column.name,
+                self.display_name_mapping.get(column.name, column.name),
                 exp.DataType.build(column.dataType, dialect=self.session.output_dialect),
                 column.nullable,
                 0,

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/base/function_alternatives.py

@@ -193,10 +193,6 @@ 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(

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/base/functions.py

@@ -486,14 +486,32 @@ def var_pop(col: ColumnOrName) -> Column:
 
 @meta(unsupported_engines=["bigquery", "postgres"])
 def skewness(col: ColumnOrName) -> Column:
-    from sqlframe.base.function_alternatives import skewness_from_skew
-
     session = _get_session()
 
+    func_name = "SKEWNESS"
+
     if session._is_snowflake:
-        return skewness_from_skew(col)
+        func_name = "SKEW"
 
-    return Column.invoke_anonymous_function(col, "SKEWNESS")
+    if session._is_duckdb or session._is_snowflake:
+        when_func = get_func_from_session("when")
+        count_func = get_func_from_session("count")
+        count_star = count_func("*")
+        lit_func = get_func_from_session("lit")
+        sqrt_func = get_func_from_session("sqrt")
+        col = Column.ensure_col(col)
+        return (
+            when_func(count_star == lit_func(0), lit_func(None))
+            .when(count_star == lit_func(1), lit_func(float("nan")))
+            .when(count_star == lit_func(2), lit_func(0.0))
+            .otherwise(
+                Column.invoke_anonymous_function(col, func_name)
+                * (count_star - lit_func(2))
+                / (sqrt_func(count_star * (count_star - lit_func(1))))
+            )
+        )
+
+    return Column.invoke_anonymous_function(col, func_name)
 
 
 @meta(unsupported_engines=["bigquery", "postgres"])
@@ -4486,7 +4504,7 @@ def median(col: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col, expression.Median)
 
 
-@meta(unsupported_engines="*")
+@meta(unsupported_engines=["bigquery", "postgres"])
 def mode(col: ColumnOrName) -> Column:
     """
     Returns the most frequent value in a group.
@@ -4522,6 +4540,7 @@ def mode(col: ColumnOrName) -> Column:
     |dotNET|      2012|
     +------+----------+
     """
+
     return Column.invoke_anonymous_function(col, "mode")
 
 

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/base/mixins/readwriter_mixins.py

@@ -82,6 +82,10 @@ class PandasLoaderMixin(_BaseDataFrameReader, t.Generic[SESSION, DF]):
         elif format == "parquet":
             df = pd.read_parquet(path, **kwargs)  # type: ignore
         elif format == "csv":
+            kwargs.pop("inferSchema", None)
+            if "header" in kwargs:
+                if isinstance(kwargs["header"], bool) and kwargs["header"]:
+                    kwargs["header"] = "infer"
             df = pd.read_csv(path, **kwargs)  # type: ignore
         else:
             raise UnsupportedOperationError(f"Unsupported format: {format}")

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/base/readerwriter.py

@@ -393,10 +393,12 @@ class _BaseDataFrameWriter(t.Generic[SESSION, DF]):
         df: DF,
         mode: t.Optional[str] = None,
         by_name: bool = False,
+        state_format_to_write: t.Optional[str] = None,
     ):
         self._df = df
         self._mode = mode
         self._by_name = by_name
+        self._state_format_to_write = state_format_to_write
 
     @property
     def _session(self) -> SESSION:
@@ -484,6 +486,44 @@ class _BaseDataFrameWriter(t.Generic[SESSION, DF]):
     def _write(self, path: str, mode: t.Optional[str], format: str, **options) -> None:
         raise NotImplementedError
 
+    def format(self, source: str) -> "Self":
+        """Specifies the input data source format.
+
+        .. versionadded:: 1.4.0
+
+        .. versionchanged:: 3.4.0
+            Supports Spark Connect.
+
+        Parameters
+        ----------
+        source : str
+            string, name of the data source, e.g. 'json', 'parquet'.
+
+        Examples
+        --------
+        >>> spark.read.format('json')
+        <...readwriter.DataFrameReader object ...>
+
+        Write a DataFrame into a JSON file and read it back.
+
+        >>> import tempfile
+        >>> with tempfile.TemporaryDirectory() as d:
+        ...     # Write a DataFrame into a JSON file
+        ...     spark.createDataFrame(
+        ...         [{"age": 100, "name": "Hyukjin Kwon"}]
+        ...     ).write.mode("overwrite").format("json").save(d)
+        ...
+        ...     # Read the JSON file as a DataFrame.
+        ...     spark.read.format('json').load(d).show()
+        +---+------------+
+        |age|        name|
+        +---+------------+
+        |100|Hyukjin Kwon|
+        +---+------------+
+        """
+        self._state_format_to_write = source
+        return self
+
     def json(
         self,
         path: str,

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/base/util.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import importlib
+import random
+import string
 import typing as t
 import unicodedata
 
@@ -97,12 +99,8 @@ def get_column_mapping_from_schema_input(
     else:
         value = {x.strip(): None for x in schema}
     return {
-        exp.to_column(k).sql(dialect=dialect): exp.DataType.build(v, dialect=dialect)
-        if v is not None
-        else v
-        for k, v in value.items()
+        k: exp.DataType.build(v, dialect=dialect) if v is not None else v for k, v in value.items()
     }
-    # return {x.strip(): None for x in schema}  # type: ignore
 
 
 def get_tables_from_expression_with_join(expression: exp.Select) -> t.List[exp.Table]:
@@ -431,3 +429,20 @@ def normalize_string(
         for pos in star_positions:
             normalized_value = normalized_value[:pos] + "*" + normalized_value[pos:]
     return normalized_value
+
+
+def generate_random_identifier(size=6, chars=string.ascii_uppercase + string.digits):
+    return "_" + "".join(random.choice(chars) for _ in range(size))
+
+
+def split_filepath(filepath: str) -> tuple[str, str]:
+    if filepath.startswith("dbfs:") or filepath.startswith("/dbfs"):
+        prefix = "dbfs:"
+        return prefix, filepath[len(prefix) :]
+    if filepath.startswith("file://"):
+        prefix = "file://"
+        return "", filepath[len(prefix) :]
+    split_ = str(filepath).split("://", 1)
+    if len(split_) == 2:  # noqa: PLR2004
+        return split_[0] + "://", split_[1]
+    return "", split_[0]

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe/duckdb/readwriter.py

@@ -92,6 +92,7 @@ class DuckDBDataFrameReader(
         if format == "delta":
             from_clause = f"delta_scan('{path}')"
         elif format:
+            options.pop("inferSchema", None)
             paths = ",".join([f"'{path}'" for path in ensure_list(path)])
             from_clause = f"read_{format}([{paths}], {to_csv(options)})"
         else:

sqlframe-3.22.0/sqlframe/spark/readwriter.py

@@ -0,0 +1,163 @@
+# This code is based on code from Apache Spark under the license found in the LICENSE file located in the 'sqlframe' folder.
+
+from __future__ import annotations
+
+import typing as t
+
+from sqlglot import exp
+from sqlglot.helper import ensure_list
+
+from sqlframe.base.readerwriter import (
+    _BaseDataFrameReader,
+    _BaseDataFrameWriter,
+    _infer_format,
+)
+from sqlframe.base.util import ensure_column_mapping, generate_random_identifier, to_csv
+
+if t.TYPE_CHECKING:
+    from sqlframe.base._typing import OptionalPrimitiveType, PathOrPaths
+    from sqlframe.base.types import StructType
+    from sqlframe.spark.dataframe import SparkDataFrame
+    from sqlframe.spark.session import SparkSession
+    from sqlframe.spark.table import SparkTable
+
+
+class SparkDataFrameReader(
+    _BaseDataFrameReader["SparkSession", "SparkDataFrame", "SparkTable"],
+):
+    def load(
+        self,
+        path: t.Optional[PathOrPaths] = None,
+        format: t.Optional[str] = None,
+        schema: t.Optional[t.Union[StructType, str]] = None,
+        **options: OptionalPrimitiveType,
+    ) -> SparkDataFrame:
+        """Loads data from a data source and returns it as a :class:`DataFrame`.
+
+        .. versionadded:: 1.4.0
+
+        .. versionchanged:: 3.4.0
+            Supports Spark Connect.
+
+        Parameters
+        ----------
+        path : str or list, t.Optional
+            t.Optional string or a list of string for file-system backed data sources.
+        format : str, t.Optional
+            t.Optional string for format of the data source. Default to 'parquet'.
+        schema : :class:`pyspark.sql.types.StructType` or str, t.Optional
+            t.Optional :class:`pyspark.sql.types.StructType` for the input schema
+            or a DDL-formatted string (For example ``col0 INT, col1 DOUBLE``).
+        **options : dict
+            all other string options
+
+        Examples
+        --------
+        Load a CSV file with format, schema and options specified.
+
+        >>> import tempfile
+        >>> with tempfile.TemporaryDirectory() as d:
+        ...     # Write a DataFrame into a CSV file with a header
+        ...     df = spark.createDataFrame([{"age": 100, "name": "Hyukjin Kwon"}])
+        ...     df.write.option("header", True).mode("overwrite").format("csv").save(d)
+        ...
+        ...     # Read the CSV file as a DataFrame with 'nullValue' option set to 'Hyukjin Kwon',
+        ...     # and 'header' option set to `True`.
+        ...     df = spark.read.load(
+        ...         d, schema=df.schema, format="csv", nullValue="Hyukjin Kwon", header=True)
+        ...     df.printSchema()
+        ...     df.show()
+        root
+         |-- age: long (nullable = true)
+         |-- name: string (nullable = true)
+        +---+----+
+        |age|name|
+        +---+----+
+        |100|NULL|
+        +---+----+
+        """
+        assert path is not None, "path is required"
+        assert isinstance(path, str), "path must be a string"
+        format = format or self.state_format_to_read or _infer_format(path)
+        if schema:
+            column_mapping = ensure_column_mapping(schema)
+            select_column_mapping = column_mapping.copy()
+            select_columns = [x.expression for x in self._to_casted_columns(select_column_mapping)]
+
+            if hasattr(schema, "simpleString"):
+                schema = schema.simpleString()
+        else:
+            select_columns = [exp.Star()]
+
+        if format == "delta":
+            from_clause = f"delta.`{path}`"
+        elif format:
+            paths = ",".join([f"{path}" for path in ensure_list(path)])
+            tmp_view_key = options.get("_tmp_view_key_", f"{generate_random_identifier()}_vw")
+            options["_tmp_view_key_"] = tmp_view_key
+
+            format_options: dict[str, OptionalPrimitiveType] = {
+                k: v for k, v in options.items() if v is not None
+            }
+            format_options.pop("_tmp_view_key_")
+            format_options["path"] = paths
+            if schema:
+                format_options["schema"] = f"{schema}"
+                format_options.pop("inferSchema", None)
+            format_options = {key: f"'{val}'" for key, val in format_options.items()}
+            format_options_str = to_csv(format_options, " ")
+
+            tmp_view = f"CREATE OR REPLACE TEMPORARY VIEW {tmp_view_key} USING {format}" + (
+                f" OPTIONS ({format_options_str})" if format_options_str else ""
+            )
+            self.session.spark_session.sql(tmp_view).collect()
+
+            from_clause = f"{tmp_view_key}"
+        else:
+            from_clause = f"'{path}'"
+
+        df = self.session.sql(
+            exp.select(*select_columns).from_(from_clause, dialect=self.session.input_dialect),
+            qualify=False,
+        )
+        if select_columns == [exp.Star()] and df.schema:
+            return self.load(path=path, format=format, schema=df.schema, **options)
+        self.session._last_loaded_file = path  # type: ignore
+        return df
+
+
+class SparkDataFrameWriter(
+    _BaseDataFrameWriter["SparkSession", "SparkDataFrame"],
+):
+    def save(
+        self,
+        path: str,
+        mode: t.Optional[str] = None,
+        format: t.Optional[str] = None,
+        partitionBy: t.Optional[t.Union[str, t.List[str]]] = None,
+        **options,
+    ):
+        format = str(format or self._state_format_to_write)
+        self._write(path, mode, format, partitionBy=partitionBy, **options)
+
+    def _write(self, path: str, mode: t.Optional[str], format: str, **options):
+        spark_df = None
+        expressions = self._df._get_expressions()
+        for i, expression in enumerate(expressions):
+            if i < len(expressions) - 1:
+                self._df.session._collect(expressions)
+            else:
+                sql = self._df.session._to_sql(expression)
+                spark_df = self._session.spark_session.sql(sql)
+        if spark_df is not None:
+            options = {k: v for k, v in options.items() if v is not None}
+            mode = str(mode or self._mode or "default")
+            spark_writer = spark_df.write.format(format).mode(mode)
+            partition_columns = options.pop("partitionBy", None)
+            compression = options.pop("compression", None)
+            if partition_columns:
+                partition_columns = options.pop("partitionBy")
+                spark_writer = spark_writer.partitionBy(*partition_columns)
+            if compression:
+                spark_writer = spark_writer.option("compression", compression)
+            spark_writer.save(path=path, **options)

{sqlframe-3.21.0 → sqlframe-3.22.0}/sqlframe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 3.21.0
+Version: 3.22.0
 Summary: Turning PySpark Into a Universal DataFrame API
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman

{sqlframe-3.21.0 → sqlframe-3.22.0}/tests/integration/engines/databricks/test_databricks_dataframe.py

@@ -71,16 +71,16 @@ root
  |-- bigint_col: bigint (nullable = true)
  |-- double_col: double (nullable = true)
  |-- string_col: string (nullable = true)
- |-- `map<string,bigint>_col`: map<string, bigint> (nullable = true)
+ |-- map<string,bigint>_col: map<string, bigint> (nullable = true)
  |    |-- key: string (nullable = true)
  |    |-- value: bigint (nullable = true)
- |-- `array<struct<a:bigint,b:bigint>>`: array<struct<a: bigint, b: bigint>> (nullable = true)
+ |-- array<struct<a:bigint,b:bigint>>: array<struct<a: bigint, b: bigint>> (nullable = true)
  |    |-- element: struct<a: bigint, b: bigint> (nullable = true)
  |    |    |-- a: bigint (nullable = true)
  |    |    |-- b: bigint (nullable = true)
- |-- `array<bigint>_col`: array<bigint> (nullable = true)
+ |-- array<bigint>_col: array<bigint> (nullable = true)
  |    |-- element: bigint (nullable = true)
- |-- `struct<a:bigint>_col`: struct<a: bigint> (nullable = true)
+ |-- struct<a:bigint>_col: struct<a: bigint> (nullable = true)
  |    |-- a: bigint (nullable = true)
  |-- date_col: date (nullable = true)
  |-- timestamp_col: timestamp (nullable = true)
@@ -126,12 +126,12 @@ def test_schema_nested(databricks_datatypes: DatabricksDataFrame):
     assert struct_fields[1].dataType == types.DoubleType()
     assert struct_fields[2].name == "string_col"
     assert struct_fields[2].dataType == types.StringType()
-    assert struct_fields[3].name == "`map<string,bigint>_col`"
+    assert struct_fields[3].name == "map<string,bigint>_col"
     assert struct_fields[3].dataType == types.MapType(
         types.StringType(),
         types.LongType(),
     )
-    assert struct_fields[4].name == "`array<struct<a:bigint,b:bigint>>`"
+    assert struct_fields[4].name == "array<struct<a:bigint,b:bigint>>"
     assert struct_fields[4].dataType == types.ArrayType(
         types.StructType(
             [
@@ -146,11 +146,11 @@ def test_schema_nested(databricks_datatypes: DatabricksDataFrame):
             ]
         ),
     )
-    assert struct_fields[5].name == "`array<bigint>_col`"
+    assert struct_fields[5].name == "array<bigint>_col"
     assert struct_fields[5].dataType == types.ArrayType(
         types.LongType(),
     )
-    assert struct_fields[6].name == "`struct<a:bigint>_col`"
+    assert struct_fields[6].name == "struct<a:bigint>_col"
     assert struct_fields[6].dataType == types.StructType(
         [
             types.StructField(

{sqlframe-3.21.0 → sqlframe-3.22.0}/tests/integration/engines/duck/test_duckdb_dataframe.py

@@ -67,16 +67,16 @@ root
  |-- bigint_col: bigint (nullable = true)
  |-- double_col: double (nullable = true)
  |-- string_col: string (nullable = true)
- |-- `map<string,bigint>_col`: map<string, bigint> (nullable = true)
+ |-- map<string,bigint>_col: map<string, bigint> (nullable = true)
  |    |-- key: string (nullable = true)
  |    |-- value: bigint (nullable = true)
- |-- `array<struct<a:bigint,b:bigint>>`: array<struct<a: bigint, b: bigint>> (nullable = true)
+ |-- array<struct<a:bigint,b:bigint>>: array<struct<a: bigint, b: bigint>> (nullable = true)
  |    |-- element: struct<a: bigint, b: bigint> (nullable = true)
  |    |    |-- a: bigint (nullable = true)
  |    |    |-- b: bigint (nullable = true)
- |-- `array<bigint>_col`: array<bigint> (nullable = true)
+ |-- array<bigint>_col: array<bigint> (nullable = true)
  |    |-- element: bigint (nullable = true)
- |-- `struct<a:bigint>_col`: struct<a: bigint> (nullable = true)
+ |-- struct<a:bigint>_col: struct<a: bigint> (nullable = true)
  |    |-- a: bigint (nullable = true)
  |-- date_col: date (nullable = true)
  |-- timestamp_col: timestamp (nullable = true)
@@ -122,12 +122,12 @@ def test_schema_nested(duckdb_datatypes: DuckDBDataFrame):
     assert struct_fields[1].dataType == types.DoubleType()
     assert struct_fields[2].name == "string_col"
     assert struct_fields[2].dataType == types.StringType()
-    assert struct_fields[3].name == "`map<string,bigint>_col`"
+    assert struct_fields[3].name == "map<string,bigint>_col"
     assert struct_fields[3].dataType == types.MapType(
         types.StringType(),
         types.LongType(),
     )
-    assert struct_fields[4].name == "`array<struct<a:bigint,b:bigint>>`"
+    assert struct_fields[4].name == "array<struct<a:bigint,b:bigint>>"
     assert struct_fields[4].dataType == types.ArrayType(
         types.StructType(
             [
@@ -142,11 +142,11 @@ def test_schema_nested(duckdb_datatypes: DuckDBDataFrame):
             ]
         ),
     )
-    assert struct_fields[5].name == "`array<bigint>_col`"
+    assert struct_fields[5].name == "array<bigint>_col"
     assert struct_fields[5].dataType == types.ArrayType(
         types.LongType(),
     )
-    assert struct_fields[6].name == "`struct<a:bigint>_col`"
+    assert struct_fields[6].name == "struct<a:bigint>_col"
     assert struct_fields[6].dataType == types.StructType(
         [
             types.StructField(

{sqlframe-3.21.0 → sqlframe-3.22.0}/tests/integration/engines/postgres/test_postgres_dataframe.py

@@ -62,7 +62,7 @@ root
  |-- bigint_col: bigint (nullable = true)
  |-- double_col: double (nullable = true)
  |-- string_col: string (nullable = true)
- |-- `array<bigint>_col`: array<bigint> (nullable = true)
+ |-- array<bigint>_col: array<bigint> (nullable = true)
  |    |-- element: bigint (nullable = true)
  |-- date_col: date (nullable = true)
  |-- timestamp_col: timestamp (nullable = true)
@@ -108,7 +108,7 @@ def test_schema_nested(postgres_datatypes: PostgresDataFrame):
     assert struct_fields[1].dataType == types.DoubleType()
     assert struct_fields[2].name == "string_col"
     assert struct_fields[2].dataType == types.StringType()
-    assert struct_fields[3].name == "`array<bigint>_col`"
+    assert struct_fields[3].name == "array<bigint>_col"
     assert struct_fields[3].dataType == types.ArrayType(
         types.LongType(),
     )