sqlframe 1.0.0__tar.gz → 1.1.0__tar.gz

{sqlframe-1.0.0 → sqlframe-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 1.0.0
+Version: 1.1.0
 Summary: Taking the Spark out of PySpark by converting to SQL
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman

{sqlframe-1.0.0 → sqlframe-1.1.0}/setup.py

@@ -20,7 +20,7 @@ setup(
     python_requires=">=3.8",
     install_requires=[
         "prettytable<3.11.0",
-        "sqlglot>=23.14.0,<23.18",
+        "sqlglot>=24.0.0,<24.1",
     ],
     extras_require={
         "bigquery": [

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0.0'
-__version_tuple__ = version_tuple = (1, 0, 0)
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe/base/catalog.py

@@ -8,7 +8,7 @@ from sqlglot import MappingSchema, exp
 
 from sqlframe.base.decorators import normalize
 from sqlframe.base.exceptions import TableSchemaError
-from sqlframe.base.util import to_schema
+from sqlframe.base.util import ensure_column_mapping, to_schema
 
 if t.TYPE_CHECKING:
     from sqlglot.schema import ColumnMapping
@@ -82,6 +82,7 @@ class _BaseCatalog(t.Generic[SESSION, DF]):
                 raise TableSchemaError(
                     "This session does not have access to a catalog that can lookup column information. See docs for explicitly defining columns or using a session that can automatically determine this."
                 )
+        column_mapping = ensure_column_mapping(column_mapping)  # type: ignore
         self._schema.add_table(table, column_mapping, dialect=self.session.input_dialect)
 
     @normalize(["dbName"])

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe/base/dataframe.py

@@ -417,7 +417,7 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         from sqlframe.base.session import _BaseSession
 
         value = expression.sql(dialect=_BaseSession().input_dialect).encode("utf-8")
-        hash = f"t{zlib.crc32(value)}"[:6]
+        hash = f"t{zlib.crc32(value)}"[:9]
         return self.session._normalize_string(hash)
 
     def _get_select_expressions(
@@ -606,8 +606,11 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         return df._convert_leaf_to_cte(sequence_id=new_sequence_id)
 
     @operation(Operation.WHERE)
-    def where(self, column: t.Union[Column, bool], **kwargs) -> Self:
-        col = self._ensure_and_normalize_col(column)
+    def where(self, column: t.Union[Column, str, bool], **kwargs) -> Self:
+        if isinstance(column, str):
+            col = sqlglot.parse_one(column, dialect=self.session.input_dialect)
+        else:
+            col = self._ensure_and_normalize_col(column)
         return self.copy(expression=self.expression.where(col.expression))
 
     filter = where
@@ -1094,7 +1097,7 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         )
         if existing_col_index:
             expression = self.expression.copy()
-            expression.expressions[existing_col_index] = col.expression
+            expression.expressions[existing_col_index] = col.alias(colName).expression
             return self.copy(expression=expression)
         return self.copy().select(col.alias(colName), append=True)
 

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe/base/session.py

@@ -313,24 +313,16 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, CONN]):
         sel_expression = exp.Select(**select_kwargs)
         if empty_df:
             sel_expression = sel_expression.where(exp.false())
-        # if empty_df:
-        #     if not column_mapping:
-        #         # If we don't have rows or columns then we just return a null with a false expression
-        #         sel_expression = (
-        #             exp.Select().select("null").from_("VALUES (NULL)").where(exp.false())
-        #         )
-        #     else:
-        #         # Ensure no results are returned if the dataframe is expected to be empty instead of
-        #         # a row of null values
-        #         sel_expression = sel_expression.where(exp.false())
         return self._create_df(sel_expression)
 
-    def sql(self, sqlQuery: t.Union[str, exp.Expression]) -> DF:
-        expression = self._optimize(
+    def sql(self, sqlQuery: t.Union[str, exp.Expression], optimize: bool = True) -> DF:
+        expression = (
             sqlglot.parse_one(sqlQuery, read=self.input_dialect)
             if isinstance(sqlQuery, str)
             else sqlQuery
         )
+        if optimize:
+            expression = self._optimize(expression)
         if self.temp_views:
             replacement_mapping = {}
             for table in expression.find_all(exp.Table):

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe/base/util.py

@@ -113,6 +113,8 @@ def ensure_column_mapping(schema: t.Union[str, StructType]) -> t.Dict:
         }
     # TODO: Make a protocol with a `simpleString` attribute as what it looks for instead of the actual
     # `StructType` object.
+    elif hasattr(schema, "simpleString"):
+        return {struct_field.name: struct_field.dataType.simpleString() for struct_field in schema}
     return sqlglot_ensure_column_mapping(schema)  # type: ignore
 
 

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe/duckdb/readwriter.py

@@ -5,6 +5,9 @@ from __future__ import annotations
 import logging
 import typing as t
 
+from sqlglot import exp
+from sqlglot.helper import ensure_list
+
 from sqlframe.base.readerwriter import _BaseDataFrameReader, _BaseDataFrameWriter
 from sqlframe.base.util import ensure_column_mapping, to_csv
 
@@ -69,13 +72,22 @@ class DuckDBDataFrameReader(_BaseDataFrameReader["DuckDBSession", "DuckDBDataFra
         |100|NULL|
         +---+----+
         """
+        if schema:
+            column_mapping = ensure_column_mapping(schema)
+            select_columns = [x.expression for x in self._to_casted_columns(column_mapping)]
+            if format == "csv":
+                duckdb_columns = ", ".join(
+                    [f"'{column}': '{dtype}'" for column, dtype in column_mapping.items()]
+                )
+                options["columns"] = "{" + duckdb_columns + "}"
+        else:
+            select_columns = [exp.Star()]
         if format:
-            sql = f"SELECT * FROM read_{format}('{path}', {to_csv(options)})"
+            paths = ",".join([f"'{path}'" for path in ensure_list(path)])
+            from_clause = f"read_{format}([{paths}], {to_csv(options)})"
         else:
-            sql = f"select * from '{path}'"
-        df = self.session.sql(sql)
-        if schema:
-            df = df.select(*self._to_casted_columns(ensure_column_mapping(schema)))
+            from_clause = f"'{path}'"
+        df = self.session.sql(exp.select(*select_columns).from_(from_clause), optimize=False)
         self.session._last_loaded_file = path  # type: ignore
         return df
 

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 1.0.0
+Version: 1.1.0
 Summary: Taking the Spark out of PySpark by converting to SQL
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe.egg-info/SOURCES.txt

@@ -145,6 +145,7 @@ tests/types.py
 tests/fixtures/employee.csv
 tests/fixtures/employee.json
 tests/fixtures/employee.parquet
+tests/fixtures/employee_extra_line.csv
 tests/integration/__init__.py
 tests/integration/fixtures.py
 tests/integration/test_int_dataframe.py
@@ -162,6 +163,7 @@ tests/integration/engines/bigquery/test_bigquery_catalog.py
 tests/integration/engines/bigquery/test_bigquery_session.py
 tests/integration/engines/duck/__init__.py
 tests/integration/engines/duck/test_duckdb_catalog.py
+tests/integration/engines/duck/test_duckdb_reader.py
 tests/integration/engines/duck/test_duckdb_session.py
 tests/integration/engines/postgres/__init__.py
 tests/integration/engines/postgres/test_postgres_catalog.py

{sqlframe-1.0.0 → sqlframe-1.1.0}/sqlframe.egg-info/requires.txt

@@ -1,5 +1,5 @@
 prettytable<3.11.0
-sqlglot<23.18,>=23.14.0
+sqlglot<24.1,>=24.0.0
 
 [bigquery]
 google-cloud-bigquery-storage<3,>=2

sqlframe-1.1.0/tests/fixtures/employee_extra_line.csv

@@ -0,0 +1,7 @@
+some,stats,that,dont,relate,to,data
+employee_id,fname,lname,age,store_id
+1,Jack,Shephard,37,1
+2,John,Locke,65,1
+3,Kate,Austen,37,2
+4,Claire,Littleton,27,2
+5,Hugo,Reyes,29,100

sqlframe-1.1.0/tests/integration/engines/duck/test_duckdb_reader.py

@@ -0,0 +1,57 @@
+from sqlframe.base.types import Row
+from sqlframe.duckdb import DuckDBSession
+
+pytest_plugins = ["tests.common_fixtures"]
+
+
+def test_employee_extra_line_csv(duckdb_session: DuckDBSession):
+    df = duckdb_session.read.load(
+        "tests/fixtures/employee_extra_line.csv",
+        format="csv",
+        schema="employee_id INT, fname STRING, lname STRING, age INT, store_id INT",
+        skip=1,
+        header=1,
+        filename=1,
+        null_padding=True,
+        ignore_errors=1,
+        auto_detect=False,
+    )
+    assert df.collect() == [
+        Row(**{"employee_id": 1, "fname": "Jack", "lname": "Shephard", "age": 37, "store_id": 1}),
+        Row(**{"employee_id": 2, "fname": "John", "lname": "Locke", "age": 65, "store_id": 1}),
+        Row(**{"employee_id": 3, "fname": "Kate", "lname": "Austen", "age": 37, "store_id": 2}),
+        Row(
+            **{"employee_id": 4, "fname": "Claire", "lname": "Littleton", "age": 27, "store_id": 2}
+        ),
+        Row(**{"employee_id": 5, "fname": "Hugo", "lname": "Reyes", "age": 29, "store_id": 100}),
+    ]
+
+
+def test_employee_extra_line_csv_multiple(duckdb_session: DuckDBSession):
+    df = duckdb_session.read.load(
+        ["tests/fixtures/employee_extra_line.csv", "tests/fixtures/employee_extra_line.csv"],
+        format="csv",
+        schema="employee_id INT, fname STRING, lname STRING, age INT, store_id INT",
+        skip=1,
+        header=1,
+        filename=1,
+        null_padding=True,
+        ignore_errors=1,
+        auto_detect=False,
+    )
+    assert df.collect() == [
+        Row(**{"employee_id": 1, "fname": "Jack", "lname": "Shephard", "age": 37, "store_id": 1}),
+        Row(**{"employee_id": 2, "fname": "John", "lname": "Locke", "age": 65, "store_id": 1}),
+        Row(**{"employee_id": 3, "fname": "Kate", "lname": "Austen", "age": 37, "store_id": 2}),
+        Row(
+            **{"employee_id": 4, "fname": "Claire", "lname": "Littleton", "age": 27, "store_id": 2}
+        ),
+        Row(**{"employee_id": 5, "fname": "Hugo", "lname": "Reyes", "age": 29, "store_id": 100}),
+        Row(**{"employee_id": 1, "fname": "Jack", "lname": "Shephard", "age": 37, "store_id": 1}),
+        Row(**{"employee_id": 2, "fname": "John", "lname": "Locke", "age": 65, "store_id": 1}),
+        Row(**{"employee_id": 3, "fname": "Kate", "lname": "Austen", "age": 37, "store_id": 2}),
+        Row(
+            **{"employee_id": 4, "fname": "Claire", "lname": "Littleton", "age": 27, "store_id": 2}
+        ),
+        Row(**{"employee_id": 5, "fname": "Hugo", "lname": "Reyes", "age": 29, "store_id": 100}),
+    ]

{sqlframe-1.0.0 → sqlframe-1.1.0}/tests/integration/test_int_dataframe.py

@@ -302,6 +302,17 @@ def test_where_multiple_chained(
     compare_frames(df_employee, dfs_employee)
 
 
+def test_where_sql_expr(
+    pyspark_employee: PySparkDataFrame,
+    get_df: t.Callable[[str], _BaseDataFrame],
+    compare_frames: t.Callable,
+):
+    employee = get_df("employee")
+    df_employee = pyspark_employee.where("age = 37 AND fname = 'Jack'")
+    dfs_employee = employee.where("age = 37 AND fname = 'Jack'")
+    compare_frames(df_employee, dfs_employee)
+
+
 def test_operators(
     pyspark_employee: PySparkDataFrame,
     get_df: t.Callable[[str], _BaseDataFrame],

sqlframe-1.1.0/tests/unit/standalone/test_dataframe.py

@@ -0,0 +1,57 @@
+import typing as t
+
+from sqlglot import expressions as exp
+
+from sqlframe.standalone import functions as F
+from sqlframe.standalone.dataframe import StandaloneDataFrame
+
+pytest_plugins = ["tests.common_fixtures", "tests.unit.standalone.fixtures"]
+
+
+def test_hash_select_expression(standalone_employee: StandaloneDataFrame):
+    expression = exp.select("cola").from_("table")
+    assert standalone_employee._create_hash_from_expression(expression) == "t17051938"
+
+
+def test_columns(standalone_employee: StandaloneDataFrame):
+    assert standalone_employee.columns == ["employee_id", "fname", "lname", "age", "store_id"]
+
+
+def test_cache(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
+    df = standalone_employee.select("fname").cache()
+    expected_statements = [
+        "DROP VIEW IF EXISTS t31563989",
+        "CACHE LAZY TABLE t31563989 OPTIONS('storageLevel' = 'MEMORY_AND_DISK') AS SELECT CAST(`a1`.`fname` AS STRING) AS `fname` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
+        "SELECT `t31563989`.`fname` AS `fname` FROM `t31563989` AS `t31563989`",
+    ]
+    compare_sql(df, expected_statements)
+
+
+def test_persist_default(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
+    df = standalone_employee.select("fname").persist()
+    expected_statements = [
+        "DROP VIEW IF EXISTS t31563989",
+        "CACHE LAZY TABLE t31563989 OPTIONS('storageLevel' = 'MEMORY_AND_DISK_SER') AS SELECT CAST(`a1`.`fname` AS STRING) AS `fname` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
+        "SELECT `t31563989`.`fname` AS `fname` FROM `t31563989` AS `t31563989`",
+    ]
+    compare_sql(df, expected_statements)
+
+
+def test_persist_storagelevel(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
+    df = standalone_employee.select("fname").persist("DISK_ONLY_2")
+    expected_statements = [
+        "DROP VIEW IF EXISTS t31563989",
+        "CACHE LAZY TABLE t31563989 OPTIONS('storageLevel' = 'DISK_ONLY_2') AS SELECT CAST(`a1`.`fname` AS STRING) AS `fname` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
+        "SELECT `t31563989`.`fname` AS `fname` FROM `t31563989` AS `t31563989`",
+    ]
+    compare_sql(df, expected_statements)
+
+
+def test_with_column_duplicate_alias(standalone_employee: StandaloneDataFrame):
+    df = standalone_employee.withColumn("fname", F.col("age").cast("string"))
+    assert df.columns == ["employee_id", "fname", "lname", "age", "store_id"]
+    # Make sure that the new columns is added with an alias to `fname`
+    assert (
+        df.sql(pretty=False)
+        == "SELECT `a1`.`employee_id` AS `employee_id`, CAST(`a1`.`age` AS STRING) AS `fname`, CAST(`a1`.`lname` AS STRING) AS `lname`, `a1`.`age` AS `age`, `a1`.`store_id` AS `store_id` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)"
+    )

{sqlframe-1.0.0 → sqlframe-1.1.0}/tests/unit/standalone/test_dataframe_writer.py

@@ -43,9 +43,9 @@ def test_insertInto_byName(standalone_employee: StandaloneDataFrame, compare_sql
 def test_insertInto_cache(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
     df = standalone_employee.cache().write.insertInto("table_name")
     expected_statements = [
-        "DROP VIEW IF EXISTS t12441",
-        "CACHE LAZY TABLE t12441 OPTIONS('storageLevel' = 'MEMORY_AND_DISK') AS SELECT `a1`.`employee_id` AS `employee_id`, CAST(`a1`.`fname` AS STRING) AS `fname`, CAST(`a1`.`lname` AS STRING) AS `lname`, `a1`.`age` AS `age`, `a1`.`store_id` AS `store_id` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
-        "INSERT INTO table_name SELECT `t12441`.`employee_id` AS `employee_id`, `t12441`.`fname` AS `fname`, `t12441`.`lname` AS `lname`, `t12441`.`age` AS `age`, `t12441`.`store_id` AS `store_id` FROM `t12441` AS `t12441`",
+        "DROP VIEW IF EXISTS t12441709",
+        "CACHE LAZY TABLE t12441709 OPTIONS('storageLevel' = 'MEMORY_AND_DISK') AS SELECT `a1`.`employee_id` AS `employee_id`, CAST(`a1`.`fname` AS STRING) AS `fname`, CAST(`a1`.`lname` AS STRING) AS `lname`, `a1`.`age` AS `age`, `a1`.`store_id` AS `store_id` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
+        "INSERT INTO table_name SELECT `t12441709`.`employee_id` AS `employee_id`, `t12441709`.`fname` AS `fname`, `t12441709`.`lname` AS `lname`, `t12441709`.`age` AS `age`, `t12441709`.`store_id` AS `store_id` FROM `t12441709` AS `t12441709`",
     ]
     compare_sql(df, expected_statements)
 
@@ -94,9 +94,9 @@ def test_mode_override(standalone_employee: StandaloneDataFrame, compare_sql: t.
 def test_saveAsTable_cache(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
     df = standalone_employee.cache().write.saveAsTable("table_name")
     expected_statements = [
-        "DROP VIEW IF EXISTS t12441",
-        "CACHE LAZY TABLE t12441 OPTIONS('storageLevel' = 'MEMORY_AND_DISK') AS SELECT `a1`.`employee_id` AS `employee_id`, CAST(`a1`.`fname` AS STRING) AS `fname`, CAST(`a1`.`lname` AS STRING) AS `lname`, `a1`.`age` AS `age`, `a1`.`store_id` AS `store_id` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
-        "CREATE TABLE table_name AS SELECT `t12441`.`employee_id` AS `employee_id`, `t12441`.`fname` AS `fname`, `t12441`.`lname` AS `lname`, `t12441`.`age` AS `age`, `t12441`.`store_id` AS `store_id` FROM `t12441` AS `t12441`",
+        "DROP VIEW IF EXISTS t12441709",
+        "CACHE LAZY TABLE t12441709 OPTIONS('storageLevel' = 'MEMORY_AND_DISK') AS SELECT `a1`.`employee_id` AS `employee_id`, CAST(`a1`.`fname` AS STRING) AS `fname`, CAST(`a1`.`lname` AS STRING) AS `lname`, `a1`.`age` AS `age`, `a1`.`store_id` AS `store_id` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
+        "CREATE TABLE table_name AS SELECT `t12441709`.`employee_id` AS `employee_id`, `t12441709`.`fname` AS `fname`, `t12441709`.`lname` AS `lname`, `t12441709`.`age` AS `age`, `t12441709`.`store_id` AS `store_id` FROM `t12441709` AS `t12441709`",
     ]
     compare_sql(df, expected_statements)
 

{sqlframe-1.0.0 → sqlframe-1.1.0}/tests/unit/standalone/test_session.py

@@ -110,7 +110,7 @@ def test_sql_with_aggs(standalone_session: StandaloneSession, compare_sql: t.Cal
     df = standalone_session.sql(query).groupBy(F.col("cola")).agg(F.sum("colb"))
     compare_sql(
         df,
-        "WITH t26614 AS (SELECT `table`.`cola` AS `cola`, `table`.`colb` AS `colb` FROM `table` AS `table`), t23454 AS (SELECT cola, colb FROM t26614) SELECT cola, SUM(colb) FROM t23454 GROUP BY cola",
+        "WITH t26614157 AS (SELECT `table`.`cola` AS `cola`, `table`.`colb` AS `colb` FROM `table` AS `table`), t38889420 AS (SELECT cola, colb FROM t26614157) SELECT cola, SUM(colb) FROM t38889420 GROUP BY cola",
         pretty=False,
         optimize=False,
     )

sqlframe-1.0.0/tests/unit/standalone/test_dataframe.py

@@ -1,46 +0,0 @@
-import typing as t
-
-from sqlglot import expressions as exp
-
-from sqlframe.standalone.dataframe import StandaloneDataFrame
-
-pytest_plugins = ["tests.common_fixtures", "tests.unit.standalone.fixtures"]
-
-
-def test_hash_select_expression(standalone_employee: StandaloneDataFrame):
-    expression = exp.select("cola").from_("table")
-    assert standalone_employee._create_hash_from_expression(expression) == "t17051"
-
-
-def test_columns(standalone_employee: StandaloneDataFrame):
-    assert standalone_employee.columns == ["employee_id", "fname", "lname", "age", "store_id"]
-
-
-def test_cache(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
-    df = standalone_employee.select("fname").cache()
-    expected_statements = [
-        "DROP VIEW IF EXISTS t31563",
-        "CACHE LAZY TABLE t31563 OPTIONS('storageLevel' = 'MEMORY_AND_DISK') AS SELECT CAST(`a1`.`fname` AS STRING) AS `fname` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
-        "SELECT `t31563`.`fname` AS `fname` FROM `t31563` AS `t31563`",
-    ]
-    compare_sql(df, expected_statements)
-
-
-def test_persist_default(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
-    df = standalone_employee.select("fname").persist()
-    expected_statements = [
-        "DROP VIEW IF EXISTS t31563",
-        "CACHE LAZY TABLE t31563 OPTIONS('storageLevel' = 'MEMORY_AND_DISK_SER') AS SELECT CAST(`a1`.`fname` AS STRING) AS `fname` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
-        "SELECT `t31563`.`fname` AS `fname` FROM `t31563` AS `t31563`",
-    ]
-    compare_sql(df, expected_statements)
-
-
-def test_persist_storagelevel(standalone_employee: StandaloneDataFrame, compare_sql: t.Callable):
-    df = standalone_employee.select("fname").persist("DISK_ONLY_2")
-    expected_statements = [
-        "DROP VIEW IF EXISTS t31563",
-        "CACHE LAZY TABLE t31563 OPTIONS('storageLevel' = 'DISK_ONLY_2') AS SELECT CAST(`a1`.`fname` AS STRING) AS `fname` FROM VALUES (1, 'Jack', 'Shephard', 37, 1), (2, 'John', 'Locke', 65, 1), (3, 'Kate', 'Austen', 37, 2), (4, 'Claire', 'Littleton', 27, 2), (5, 'Hugo', 'Reyes', 29, 100) AS `a1`(`employee_id`, `fname`, `lname`, `age`, `store_id`)",
-        "SELECT `t31563`.`fname` AS `fname` FROM `t31563` AS `t31563`",
-    ]
-    compare_sql(df, expected_statements)