sqlframe 3.15.1__tar.gz → 3.17.0__tar.gz

{sqlframe-3.15.1 → sqlframe-3.17.0}/Makefile

@@ -13,17 +13,8 @@ fast-test:
 local-test:
 	pytest -n auto -m "fast or local"
 
-bigquery-test:
-	pytest -n auto -m "bigquery"
-
-duckdb-test:
-	pytest -n auto -m "duckdb"
-
-snowflake-test:
-	pytest -n auto -m "snowflake"
-
-databricks-test:
-	pytest -n auto -m "databricks"
+%-test:
+	pytest -n auto -m "${*}"
 
 style:
 	pre-commit run --all-files

{sqlframe-3.15.1 → sqlframe-3.17.0}/PKG-INFO

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

{sqlframe-3.15.1 → sqlframe-3.17.0}/docs/bigquery.md

@@ -334,6 +334,7 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [bool_and](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bool_and.html)
 * [bool_or](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bool_or.html)
 * [bround](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bround.html)
+* [btrim](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.btrim.html)
 * [call_function](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.call_function.html)
 * [cbrt](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.cbrt.html)
 * [ceil](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.ceil.html)

{sqlframe-3.15.1 → sqlframe-3.17.0}/docs/duckdb.md

@@ -296,6 +296,7 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [bitwise_not](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bitwise_not.html)
 * [bool_and](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bool_and.html)
 * [bool_or](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bool_or.html)
+* [btrim](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.btrim.html)
 * [call_function](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.call_function.html)
 * [cbrt](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.cbrt.html)
 * [ceil](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.ceil.html)

{sqlframe-3.15.1 → sqlframe-3.17.0}/docs/postgres.md

@@ -306,6 +306,7 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [bitwise_not](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bitwise_not.html)
 * [bool_and](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bool_and.html)
 * [bool_or](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bool_or.html)
+* [btrim](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.btrim.html)
 * [call_function](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.call_function.html)
 * [cbrt](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.cbrt.html)
 * [ceil](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.ceil.html)

{sqlframe-3.15.1 → sqlframe-3.17.0}/docs/snowflake.md

@@ -332,6 +332,7 @@ See something that you would like to see supported? [Open an issue](https://gith
 * [bool_or](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bool_or.html)
 * [bround](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.bround.html)
   * [Input must be a fixed-point nnumber](https://docs.snowflake.com/en/sql-reference/data-types-numeric.html#label-data-types-for-fixed-point-numbers)
+* [btrim](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.btrim.html)
 * [call_function](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.call_function.html)
 * [cbrt](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.cbrt.html)
 * [ceil](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.functions.ceil.html)

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.15.1'
-__version_tuple__ = version_tuple = (3, 15, 1)
+__version__ = version = '3.17.0'
+__version_tuple__ = version_tuple = (3, 17, 0)

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe/base/column.py

@@ -291,6 +291,7 @@ class Column:
             this=self.column_expression,
             alias=alias.this if isinstance(alias, exp.Column) else alias,
         )
+        new_expression._meta = {"display_name": name, **(new_expression._meta or {})}
         return Column(new_expression)
 
     def asc(self) -> Column:

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe/base/dataframe.py

@@ -233,6 +233,7 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         last_op: Operation = Operation.INIT,
         pending_hints: t.Optional[t.List[exp.Expression]] = None,
         output_expression_container: t.Optional[OutputExpressionContainer] = None,
+        display_name_mapping: t.Optional[t.Dict[str, str]] = None,
         **kwargs,
     ):
         self.session = session
@@ -246,6 +247,7 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         self.pending_hints = pending_hints or []
         self.output_expression_container = output_expression_container or exp.Select()
         self.temp_views: t.List[exp.Select] = []
+        self.display_name_mapping = display_name_mapping or {}
 
     def __getattr__(self, column_name: str) -> Column:
         return self[column_name]
@@ -385,13 +387,16 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         return Column.ensure_cols(ensure_list(cols))  # type: ignore
 
     def _ensure_and_normalize_cols(
-        self, cols, expression: t.Optional[exp.Select] = None
+        self, cols, expression: t.Optional[exp.Select] = None, skip_star_expansion: bool = False
     ) -> t.List[Column]:
         from sqlframe.base.normalize import normalize
 
         cols = self._ensure_list_of_columns(cols)
         normalize(self.session, expression or self.expression, cols)
-        return list(flatten([self._expand_star(col) for col in cols]))
+        if not skip_star_expansion:
+            cols = list(flatten([self._expand_star(col) for col in cols]))
+        self._resolve_ambiguous_columns(cols)
+        return cols
 
     def _ensure_and_normalize_col(self, col):
         from sqlframe.base.column import Column
@@ -399,6 +404,7 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
 
         col = Column.ensure_col(col)
         normalize(self.session, self.expression, col)
+        self._resolve_ambiguous_columns(col)
         return col
 
     def _convert_leaf_to_cte(
@@ -589,6 +595,23 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
             )
         return [col]
 
+    def _update_display_name_mapping(
+        self, normalized_columns: t.List[Column], user_input: t.Iterable[ColumnOrName]
+    ) -> None:
+        from sqlframe.base.column import Column
+
+        normalized_aliases = [x.alias_or_name for x in normalized_columns]
+        user_display_names = [
+            x.expression.meta.get("display_name") if isinstance(x, Column) else x
+            for x in user_input
+        ]
+        zipped = {
+            k: v
+            for k, v in dict(zip(normalized_aliases, user_display_names)).items()
+            if v is not None
+        }
+        self.display_name_mapping.update(zipped)
+
     def _get_expressions(
         self,
         optimize: bool = True,
@@ -608,6 +631,16 @@ 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
+                    )
             if optimize:
                 select_expression = t.cast(
                     exp.Select,
@@ -745,59 +778,73 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         kwargs["join_on_uuid"] = str(uuid4())
         return self.__class__(**object_to_dict(self, **kwargs))
 
+    def _resolve_ambiguous_columns(self, columns: t.Union[Column, t.List[Column]]) -> None:
+        if "joins" not in self.expression.args:
+            return
+
+        columns = ensure_list(columns)
+        ambiguous_cols: t.List[exp.Column] = list(
+            flatten(
+                [
+                    sub_col
+                    for col in columns
+                    for sub_col in col.expression.find_all(exp.Column)
+                    if not sub_col.table
+                ]
+            )
+        )
+        if ambiguous_cols:
+            join_table_identifiers = [
+                x.this for x in get_tables_from_expression_with_join(self.expression)
+            ]
+            cte_names_in_join = [x.this for x in join_table_identifiers]
+            # If we have columns that resolve to multiple CTE expressions then we want to use each CTE left-to-right
+            # (or right to left if a right join) and therefore we allow multiple columns with the same
+            # name in the result. This matches the behavior of Spark.
+            resolved_column_position: t.Dict[exp.Column, int] = {
+                col.copy(): -1 for col in ambiguous_cols
+            }
+            for ambiguous_col in ambiguous_cols:
+                ctes = (
+                    list(reversed(self.expression.ctes))
+                    if self.expression.args["joins"][0].args.get("side", "") == "right"
+                    else self.expression.ctes
+                )
+                ctes_with_column = [
+                    cte
+                    for cte in ctes
+                    if cte.alias_or_name in cte_names_in_join
+                    and ambiguous_col.alias_or_name in cte.this.named_selects
+                ]
+                # Check if there is a CTE with this column that we haven't used before. If so, use it. Otherwise,
+                # use the same CTE we used before
+                cte = seq_get(ctes_with_column, resolved_column_position[ambiguous_col] + 1)
+                if cte:
+                    resolved_column_position[ambiguous_col] += 1
+                else:
+                    cte = ctes_with_column[resolved_column_position[ambiguous_col]]
+                ambiguous_col.set("table", exp.to_identifier(cte.alias_or_name))
+
     @operation(Operation.SELECT)
     def select(self, *cols, **kwargs) -> Self:
-        from sqlframe.base.column import Column
-
         if not cols:
             return self
 
         if isinstance(cols[0], list):
             cols = cols[0]  # type: ignore
         columns = self._ensure_and_normalize_cols(cols)
+        if "skip_update_display_name_mapping" not in kwargs:
+            unexpanded_columns = self._ensure_and_normalize_cols(cols, skip_star_expansion=True)
+            user_cols = list(cols)
+            star_columns = []
+            for index, user_col in enumerate(cols):
+                if "*" in (user_col if isinstance(user_col, str) else user_col.alias_or_name):
+                    star_columns.append(index)
+            for index in star_columns:
+                unexpanded_columns.pop(index)
+                user_cols.pop(index)
+            self._update_display_name_mapping(unexpanded_columns, user_cols)
         kwargs["append"] = kwargs.get("append", False)
-        if self.expression.args.get("joins"):
-            ambiguous_cols: t.List[exp.Column] = list(
-                flatten(
-                    [
-                        sub_col
-                        for col in columns
-                        for sub_col in col.expression.find_all(exp.Column)
-                        if not sub_col.table
-                    ]
-                )
-            )
-            if ambiguous_cols:
-                join_table_identifiers = [
-                    x.this for x in get_tables_from_expression_with_join(self.expression)
-                ]
-                cte_names_in_join = [x.this for x in join_table_identifiers]
-                # If we have columns that resolve to multiple CTE expressions then we want to use each CTE left-to-right
-                # (or right to left if a right join) and therefore we allow multiple columns with the same
-                # name in the result. This matches the behavior of Spark.
-                resolved_column_position: t.Dict[exp.Column, int] = {
-                    col.copy(): -1 for col in ambiguous_cols
-                }
-                for ambiguous_col in ambiguous_cols:
-                    ctes = (
-                        list(reversed(self.expression.ctes))
-                        if self.expression.args["joins"][0].args.get("side", "") == "right"
-                        else self.expression.ctes
-                    )
-                    ctes_with_column = [
-                        cte
-                        for cte in ctes
-                        if cte.alias_or_name in cte_names_in_join
-                        and ambiguous_col.alias_or_name in cte.this.named_selects
-                    ]
-                    # Check if there is a CTE with this column that we haven't used before. If so, use it. Otherwise,
-                    # use the same CTE we used before
-                    cte = seq_get(ctes_with_column, resolved_column_position[ambiguous_col] + 1)
-                    if cte:
-                        resolved_column_position[ambiguous_col] += 1
-                    else:
-                        cte = ctes_with_column[resolved_column_position[ambiguous_col]]
-                    ambiguous_col.set("table", exp.to_identifier(cte.alias_or_name))
         # If an expression is `CAST(x AS DATETYPE)` then we want to alias so that `x` is the result column name
         columns = [
             col.alias(col.expression.alias_or_name)
@@ -846,6 +893,7 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
     @operation(Operation.SELECT)
     def agg(self, *exprs, **kwargs) -> Self:
         cols = self._ensure_and_normalize_cols(exprs)
+        self._update_display_name_mapping(cols, exprs)
         return self.groupBy().agg(*cols)
 
     @operation(Operation.FROM)
@@ -1045,7 +1093,9 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         new_df = self.copy(expression=join_expression)
         new_df.pending_join_hints.extend(self.pending_join_hints)
         new_df.pending_hints.extend(other_df.pending_hints)
-        new_df = new_df.select.__wrapped__(new_df, *select_column_names)  # type: ignore
+        new_df = new_df.select.__wrapped__(  # type: ignore
+            new_df, *select_column_names, skip_update_display_name_mapping=True
+        )
         return new_df
 
     @operation(Operation.ORDER_BY)
@@ -1435,20 +1485,18 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
     def withColumnRenamed(self, existing: str, new: str) -> Self:
         expression = self.expression.copy()
         existing = self.session._normalize_string(existing)
-        new = self.session._normalize_string(new)
-        existing_columns = [
-            expression
-            for expression in expression.expressions
-            if expression.alias_or_name == existing
-        ]
-        if not existing_columns:
+        columns = self._get_outer_select_columns(expression)
+        results = []
+        found_match = False
+        for column in columns:
+            if column.alias_or_name == existing:
+                column = column.alias(new)
+                self._update_display_name_mapping([column], [new])
+                found_match = True
+            results.append(column)
+        if not found_match:
             raise ValueError("Tried to rename a column that doesn't exist")
-        for existing_column in existing_columns:
-            if isinstance(existing_column, exp.Column):
-                existing_column.replace(exp.alias_(existing_column, new))
-            else:
-                existing_column.set("alias", exp.to_identifier(new))
-        return self.copy(expression=expression)
+        return self.select.__wrapped__(self, *results, skip_update_display_name_mapping=True)  # type: ignore
 
     @operation(Operation.SELECT)
     def withColumns(self, *colsMap: t.Dict[str, Column]) -> Self:
@@ -1489,23 +1537,27 @@ class BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         if len(colsMap) != 1:
             raise ValueError("Only a single map is supported")
         col_map = {
-            self._ensure_and_normalize_col(k).alias_or_name: self._ensure_and_normalize_col(v)
+            self._ensure_and_normalize_col(k): (self._ensure_and_normalize_col(v), k)
             for k, v in colsMap[0].items()
         }
         existing_cols = self._get_outer_select_columns(self.expression)
         existing_col_names = [x.alias_or_name for x in existing_cols]
         select_columns = existing_cols
-        for column_name, col_value in col_map.items():
+        for col, (col_value, display_name) in col_map.items():
+            column_name = col.alias_or_name
             existing_col_index = (
                 existing_col_names.index(column_name) if column_name in existing_col_names else None
             )
             if existing_col_index is not None:
                 select_columns[existing_col_index] = col_value.alias(  # type: ignore
-                    column_name
-                ).expression
+                    display_name
+                )
             else:
-                select_columns.append(col_value.alias(column_name))
-        return self.select.__wrapped__(self, *select_columns)  # type: ignore
+                select_columns.append(col_value.alias(display_name))
+        self._update_display_name_mapping(
+            [col for col in col_map], [name for _, name in col_map.values()]
+        )
+        return self.select.__wrapped__(self, *select_columns, skip_update_display_name_mapping=True)  # type: ignore
 
     @operation(Operation.SELECT)
     def drop(self, *cols: t.Union[str, Column]) -> Self:

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe/base/decorators.py

@@ -43,7 +43,7 @@ def func_metadata(unsupported_engines: t.Optional[t.Union[str, t.List[str]]] = N
                         col_name = col_name.this
                 alias_name = f"{func.__name__}__{col_name or ''}__"
                 # BigQuery has restrictions on alias names so we constrain it to alphanumeric characters and underscores
-                return result.alias(re.sub("\W", "_", alias_name))  # type: ignore
+                return result.alias(re.sub(r"\W", "_", alias_name))  # type: ignore
             return result
 
         wrapper.unsupported_engines = (  # type: ignore

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe/base/functions.py

@@ -39,11 +39,19 @@ def col(column_name: t.Union[ColumnOrName, t.Any]) -> Column:
 
     dialect = _BaseSession().input_dialect
     if isinstance(column_name, str):
-        return Column(
-            expression.to_column(column_name, dialect=dialect).transform(
-                dialect.normalize_identifier
-            )
+        col_expression = expression.to_column(column_name, dialect=dialect).transform(
+            dialect.normalize_identifier
         )
+        case_sensitive_expression = expression.to_column(column_name, dialect=dialect)
+        if not isinstance(
+            case_sensitive_expression, (expression.Star, expression.Literal, expression.Null)
+        ):
+            col_expression._meta = {
+                "display_name": case_sensitive_expression.this.this,
+                **(col_expression._meta or {}),
+            }
+
+        return Column(col_expression)
     return Column(column_name)
 
 
@@ -2851,12 +2859,14 @@ def bool_or(col: ColumnOrName) -> Column:
     return Column.invoke_expression_over_column(col, expression.LogicalOr)
 
 
-@meta(unsupported_engines="*")
+@meta()
 def btrim(str: ColumnOrName, trim: t.Optional[ColumnOrName] = None) -> Column:
     if trim is not None:
-        return Column.invoke_anonymous_function(str, "btrim", trim)
+        return Column.invoke_expression_over_column(
+            str, expression.Trim, expression=Column.ensure_col(trim).column_expression
+        )
     else:
-        return Column.invoke_anonymous_function(str, "btrim")
+        return Column.invoke_expression_over_column(str, expression.Trim)
 
 
 @meta(unsupported_engines="*")

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe/base/session.py

@@ -507,9 +507,14 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, TABLE, CONN, UDF_REGIS
         result = self._cur.fetchall()
         if not self._cur.description:
             return []
+        case_sensitive_cols = []
+        for col in self._cur.description:
+            col_id = exp.parse_identifier(col[0], dialect=self.execution_dialect)
+            col_id._meta = {"case_sensitive": True, **(col_id._meta or {})}
+            case_sensitive_cols.append(col_id)
         columns = [
-            normalize_string(x[0], from_dialect="execution", to_dialect="output", is_column=True)
-            for x in self._cur.description
+            normalize_string(x, from_dialect="execution", to_dialect="output")
+            for x in case_sensitive_cols
         ]
         return [self._to_row(columns, row) for row in result]
 

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe/spark/session.py

@@ -79,17 +79,18 @@ class SparkSession(
         if skip_rows:
             return []
         assert self._last_df is not None
-        return [
-            Row(
-                **{
-                    normalize_string(
-                        k, from_dialect="execution", to_dialect="output", is_column=True
-                    ): v
-                    for k, v in row.asDict().items()
-                }
-            )
-            for row in self._last_df.collect()
-        ]
+        results = []
+        for row in self._last_df.collect():
+            rows_normalized = {}
+            for k, v in row.asDict().items():
+                col_id = exp.parse_identifier(k, dialect=self.execution_dialect)
+                col_id._meta = {"case_sensitive": True, **(col_id._meta or {})}
+                col_name = normalize_string(
+                    col_id, from_dialect="execution", to_dialect="output", is_column=True
+                )
+                rows_normalized[col_name] = v
+            results.append(Row(**rows_normalized))
+        return results
 
     def _execute(self, sql: str) -> None:
         self._last_df = self.spark_session.sql(sql)

{sqlframe-3.15.1 → sqlframe-3.17.0}/sqlframe.egg-info/PKG-INFO

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

{sqlframe-3.15.1 → sqlframe-3.17.0}/tests/integration/engines/test_engine_dataframe.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import typing as t
 
 from sqlframe.base.types import Row
+from sqlframe.snowflake import SnowflakeSession
+from sqlframe.spark import SparkSession
 
 if t.TYPE_CHECKING:
     from sqlframe.base.dataframe import BaseDataFrame
@@ -31,20 +33,30 @@ def test_show(
 ):
     employee = get_engine_df("employee")
     lit = get_func("lit", employee.session)
-    employee = employee.select("*", lit(1).alias("one"))
+    col = get_func("col", employee.session)
+    employee = (
+        employee.select("EmPloyee_Id", "fname", "lnamE", "AGE", "stoRe_iD", lit(1).alias("One"))
+        .withColumnRenamed("sToRe_id", "SToRE_Id")
+        .withColumns(
+            {
+                "lNamE": col("lname"),
+                "tWo": lit(2),
+            }
+        )
+    )
     employee.show()
     captured = capsys.readouterr()
     assert (
         captured.out
-        == """+-------------+--------+-----------+-----+----------+-----+
-| employee_id | fname  |   lname   | age | store_id | one |
-+-------------+--------+-----------+-----+----------+-----+
-|      1      |  Jack  |  Shephard |  37 |    1     |  1  |
-|      2      |  John  |   Locke   |  65 |    1     |  1  |
-|      3      |  Kate  |   Austen  |  37 |    2     |  1  |
-|      4      | Claire | Littleton |  27 |    2     |  1  |
-|      5      |  Hugo  |   Reyes   |  29 |   100    |  1  |
-+-------------+--------+-----------+-----+----------+-----+\n"""
+        == """+-------------+--------+-----------+-----+----------+-----+-----+
+| EmPloyee_Id | fname  |   lNamE   | AGE | SToRE_Id | One | tWo |
++-------------+--------+-----------+-----+----------+-----+-----+
+|      1      |  Jack  |  Shephard |  37 |    1     |  1  |  2  |
+|      2      |  John  |   Locke   |  65 |    1     |  1  |  2  |
+|      3      |  Kate  |   Austen  |  37 |    2     |  1  |  2  |
+|      4      | Claire | Littleton |  27 |    2     |  1  |  2  |
+|      5      |  Hugo  |   Reyes   |  29 |   100    |  1  |  2  |
++-------------+--------+-----------+-----+----------+-----+-----+\n"""
     )
     assert "Truncate is ignored so full results will be displayed" not in caplog.text
     employee.show(truncate=True)
@@ -58,11 +70,21 @@ def test_show_limit(
     employee = get_engine_df("employee")
     employee.show(1)
     captured = capsys.readouterr()
-    assert (
-        captured.out
-        == """+-------------+-------+----------+-----+----------+
+    if isinstance(employee.session, SnowflakeSession):
+        assert (
+            captured.out
+            == """+-------------+-------+----------+-----+----------+
+| EMPLOYEE_ID | FNAME |  LNAME   | AGE | STORE_ID |
++-------------+-------+----------+-----+----------+
+|      1      |  Jack | Shephard |  37 |    1     |
++-------------+-------+----------+-----+----------+\n"""
+        )
+    else:
+        assert (
+            captured.out
+            == """+-------------+-------+----------+-----+----------+
 | employee_id | fname |  lname   | age | store_id |
 +-------------+-------+----------+-----+----------+
 |      1      |  Jack | Shephard |  37 |    1     |
 +-------------+-------+----------+-----+----------+\n"""
-    )
+        )

{sqlframe-3.15.1 → sqlframe-3.17.0}/tests/integration/engines/test_int_functions.py

@@ -241,7 +241,7 @@ def test_alias(get_session_and_func):
             DatabricksSession,
         ),
     ):
-        assert space_result == "`a space in new name`"
+        assert space_result == "`A Space In New Name`"
     else:
         assert space_result == "A Space In New Name"
 

{sqlframe-3.15.1 → sqlframe-3.17.0}/tests/integration/test_int_dataframe.py

@@ -9,7 +9,7 @@ from pyspark.sql import functions as F
 
 from sqlframe.standalone import functions as SF
 from sqlframe.standalone.dataframe import StandaloneDataFrame
-from tests.integration.fixtures import StandaloneSession
+from tests.integration.fixtures import StandaloneSession, is_snowflake
 
 if t.TYPE_CHECKING:
     from sqlframe.base.dataframe import BaseDataFrame
@@ -1780,6 +1780,7 @@ def test_with_columns_reference_another(
     compare_frames: t.Callable,
     is_bigquery: t.Callable,
     is_postgres: t.Callable,
+    is_snowflake: t.Callable,
 ):
     # Could consider two options:
     # 1. Use SQLGlot optimizer to properly change the references to be expanded to avoid the issue (a rule already does this)
@@ -1792,6 +1793,14 @@ def test_with_columns_reference_another(
         pytest.skip(
             "Postgres doesn't support having selects with columns that reference each other."
         )
+    if is_snowflake():
+        # Snowflake does allow columns that reference each other but the issue is that if you do this in the final
+        # select the columns are replaced with their alias version to show their display name (the case-sensitive
+        # name provided by the user) and then, since the column is now aliased and case-sensitive, SF thinks
+        # the column doesn't exist since the column of the same case does not exist since it was aliased.
+        pytest.skip(
+            "Bugged behavior introduced display names means that snowflake can no longer reference itself."
+        )
     employee = get_df("employee")
     df = pyspark_employee.withColumns(
         {
@@ -2381,3 +2390,27 @@ def test_union_common_root_again(
     dfs_final = dfs_1.union(dfs_2).union(employee)
 
     compare_frames(df_final, dfs_final, compare_schema=False)
+
+
+# https://github.com/eakmanrq/sqlframe/issues/277
+def test_filtering_join_key(
+    pyspark_employee: PySparkDataFrame,
+    pyspark_store: PySparkDataFrame,
+    get_df: t.Callable[[str], BaseDataFrame],
+    compare_frames: t.Callable,
+):
+    df = pyspark_employee.join(
+        pyspark_store,
+        on="store_id",
+        how="inner",
+    ).filter(F.col("store_id") > 1)
+
+    employee = get_df("employee")
+    store = get_df("store")
+    dfs = employee.join(
+        store,
+        on="store_id",
+        how="inner",
+    ).filter(SF.col("store_id") > 1)
+
+    compare_frames(df, dfs, compare_schema=False, sort=True)

{sqlframe-3.15.1 → sqlframe-3.17.0}/tests/unit/standalone/test_dataframe.py

@@ -55,7 +55,7 @@ def test_with_column_duplicate_alias(standalone_employee: StandaloneDataFrame):
     # 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`)"
+        == "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`)"
     )
 
 
@@ -86,7 +86,7 @@ def test_transform(standalone_employee: StandaloneDataFrame):
     df = standalone_employee.transform(cast_all_to_int).transform(sort_columns_asc)
     assert df.columns == ["age", "employee_id", "fname", "lname", "store_id"]
     assert df.sql(pretty=False, optimize=False).endswith(  # type: ignore
-        "SELECT CAST(`employee_id` AS INT) AS `employee_id`, CAST(`fname` AS INT) AS `fname`, CAST(`lname` AS INT) AS `lname`, CAST(`age` AS INT) AS `age`, CAST(`store_id` AS INT) AS `store_id` FROM `t51718876`) SELECT `age`, `employee_id`, `fname`, `lname`, `store_id` FROM `t16881256`"
+        "SELECT CAST(`employee_id` AS INT) AS `employee_id`, CAST(`fname` AS INT) AS `fname`, CAST(`lname` AS INT) AS `lname`, CAST(`age` AS INT) AS `age`, CAST(`store_id` AS INT) AS `store_id` FROM `t51718876`) SELECT `age` AS `age`, `employee_id` AS `employee_id`, `fname` AS `fname`, `lname` AS `lname`, `store_id` AS `store_id` FROM `t16881256`"
     )