sqlframe 1.2.0__tar.gz → 1.4.0__tar.gz

{sqlframe-1.2.0 → sqlframe-1.4.0}/Makefile

@@ -1,5 +1,5 @@
 install-dev:
-	pip install -e ".[dev,docs,duckdb,postgres,redshift,bigquery,snowflake,spark]"
+	pip install -e ".[bigquery,dev,docs,duckdb,pandas,postgres,redshift,snowflake,spark]"
 
 install-pre-commit:
 	pre-commit install
@@ -8,7 +8,7 @@ slow-test:
 	pytest -n auto tests
 
 fast-test:
-	pytest -n auto -m "fast"
+	pytest -n auto tests/unit
 
 local-test:
 	pytest -n auto -m "fast or local"

{sqlframe-1.2.0 → sqlframe-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 1.2.0
+Version: 1.4.0
 Summary: Taking the Spark out of PySpark by converting to SQL
 Home-page: https://github.com/eakmanrq/sqlframe
 Author: Ryan Eakman
@@ -20,6 +20,8 @@ Provides-Extra: bigquery
 Provides-Extra: dev
 Provides-Extra: docs
 Provides-Extra: duckdb
+Provides-Extra: openai
+Provides-Extra: pandas
 Provides-Extra: postgres
 Provides-Extra: redshift
 Provides-Extra: snowflake
@@ -27,19 +29,19 @@ Provides-Extra: spark
 License-File: LICENSE
 
 <div align="center">
-  <img src="https://sqlframe.readthedocs.io/en/latest/docs/images/sqlframe_logo.png" alt="SQLFrame Logo" width="400"/>
+  <img src="https://sqlframe.readthedocs.io/en/stable/docs/images/sqlframe_logo.png" alt="SQLFrame Logo" width="400"/>
 </div>
 
 SQLFrame implements the PySpark DataFrame API in order to enable running transformation pipelines directly on database engines - no Spark clusters or dependencies required.
 
 SQLFrame currently supports the following engines (many more in development):
 
-* [BigQuery](https://sqlframe.readthedocs.io/en/latest/bigquery/)
-* [DuckDB](https://sqlframe.readthedocs.io/en/latest/duckdb)
-* [Postgres](https://sqlframe.readthedocs.io/en/latest/postgres)
+* [BigQuery](https://sqlframe.readthedocs.io/en/stable/bigquery/)
+* [DuckDB](https://sqlframe.readthedocs.io/en/stable/duckdb)
+* [Postgres](https://sqlframe.readthedocs.io/en/stable/postgres)
 
 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/latest/standalone)
+* [Standalone](https://sqlframe.readthedocs.io/en/stable/standalone)
 
 SQLFrame is great for:
 
@@ -62,6 +64,12 @@ pip install sqlframe
 
 See specific engine documentation for additional setup instructions.
 
+## Configuration
+
+SQLFrame generates consistently accurate yet complex SQL for engine execution. 
+However, when using df.sql(), it produces more human-readable SQL. 
+For details on how to configure this output and leverage OpenAI to enhance the SQL, see [Generated SQL Configuration](https://sqlframe.readthedocs.io/en/stable/configuration/#generated-sql).
+
 ## Example Usage
 
 ```python

{sqlframe-1.2.0 → sqlframe-1.4.0}/README.md

@@ -1,17 +1,17 @@
 <div align="center">
-  <img src="https://sqlframe.readthedocs.io/en/latest/docs/images/sqlframe_logo.png" alt="SQLFrame Logo" width="400"/>
+  <img src="https://sqlframe.readthedocs.io/en/stable/docs/images/sqlframe_logo.png" alt="SQLFrame Logo" width="400"/>
 </div>
 
 SQLFrame implements the PySpark DataFrame API in order to enable running transformation pipelines directly on database engines - no Spark clusters or dependencies required.
 
 SQLFrame currently supports the following engines (many more in development):
 
-* [BigQuery](https://sqlframe.readthedocs.io/en/latest/bigquery/)
-* [DuckDB](https://sqlframe.readthedocs.io/en/latest/duckdb)
-* [Postgres](https://sqlframe.readthedocs.io/en/latest/postgres)
+* [BigQuery](https://sqlframe.readthedocs.io/en/stable/bigquery/)
+* [DuckDB](https://sqlframe.readthedocs.io/en/stable/duckdb)
+* [Postgres](https://sqlframe.readthedocs.io/en/stable/postgres)
 
 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/latest/standalone)
+* [Standalone](https://sqlframe.readthedocs.io/en/stable/standalone)
 
 SQLFrame is great for:
 
@@ -34,6 +34,12 @@ pip install sqlframe
 
 See specific engine documentation for additional setup instructions.
 
+## Configuration
+
+SQLFrame generates consistently accurate yet complex SQL for engine execution. 
+However, when using df.sql(), it produces more human-readable SQL. 
+For details on how to configure this output and leverage OpenAI to enhance the SQL, see [Generated SQL Configuration](https://sqlframe.readthedocs.io/en/stable/configuration/#generated-sql).
+
 ## Example Usage
 
 ```python

sqlframe-1.4.0/docs/configuration.md

@@ -0,0 +1,242 @@
+# General Configuration
+
+## Generated SQL
+
+### Pretty
+
+If the SQL should be returned in a "pretty" format meaning it has newlines and indentation. Defaults to `True`.
+
+```python
+from sqlframe.standalone import StandaloneSession
+
+session = StandaloneSession()
+
+df = session.createDataFrame([{'a': 1, 'b': 2}])
+```
+```python
+>>> print(df.sql())
+SELECT
+  CAST(`a1`.`a` AS BIGINT) AS `a`,
+  CAST(`a1`.`b` AS BIGINT) AS `b`
+FROM VALUES
+  (1, 2) AS `a1`(`a`, `b`)
+```
+```python
+>>> print(df.sql(pretty=False))
+SELECT CAST(`a3`.`a` AS BIGINT) AS `a`, CAST(`a3`.`b` AS BIGINT) AS `b` FROM VALUES (1, 2) AS `a3`(`a`, `b`)
+```
+
+### Optimized
+
+Optimized SQL is SQL that has been processed by SQLGlot's optimizer. For complex queries this will significantly reduce the number of CTEs produced and remove extra unused columns. Defaults to `True`.
+
+```python
+from sqlframe.bigquery import BigQuerySession
+from sqlframe.bigquery import functions as F
+from sqlframe.bigquery import Window
+
+session = BigQuerySession()
+table_path = "bigquery-public-data.samples.natality"
+# Top 5 years with the greatest year-over-year % change in new families with single child
+df = (
+    session.table(table_path)
+    .where(F.col("ever_born") == 1)
+    .groupBy("year")
+    .agg(F.count("*").alias("num_single_child_families"))
+    .withColumn(
+        "last_year_num_single_child_families", 
+        F.lag(F.col("num_single_child_families"), 1).over(Window.orderBy("year"))
+    )
+    .withColumn(
+        "percent_change", 
+        (F.col("num_single_child_families") - F.col("last_year_num_single_child_families")) 
+        / F.col("last_year_num_single_child_families")
+    )
+    .orderBy(F.abs(F.col("percent_change")).desc())
+    .select(
+        F.col("year").alias("year"),
+        F.format_number("num_single_child_families", 0).alias("new families single child"),
+        F.format_number(F.col("percent_change") * 100, 2).alias("percent change"),
+    )
+    .limit(5)
+)
+```
+```python
+>>> print(df.sql(optimize=True))
+WITH `t94228042` AS (
+  SELECT
+    `natality`.`year` AS `year`,
+    COUNT(*) AS `num_single_child_families`
+  FROM `bigquery-public-data`.`samples`.`natality` AS `natality`
+  WHERE
+    `natality`.`ever_born` = 1
+  GROUP BY
+    `natality`.`year`
+), `t30206548` AS (
+  SELECT
+    `t94228042`.`year` AS `year`,
+    `t94228042`.`num_single_child_families` AS `num_single_child_families`,
+    LAG(`t94228042`.`num_single_child_families`, 1) OVER (ORDER BY `t94228042`.`year`) AS `last_year_num_single_child_families`
+  FROM `t94228042` AS `t94228042`
+)
+SELECT
+  `t30206548`.`year` AS `year`,
+  FORMAT('%\'.0f', ROUND(CAST(`t30206548`.`num_single_child_families` AS FLOAT64), 0)) AS `new families single child`,
+  FORMAT(
+    '%\'.2f',
+    ROUND(
+      CAST((
+        (
+          (
+            `t30206548`.`num_single_child_families` - `t30206548`.`last_year_num_single_child_families`
+          ) / `t30206548`.`last_year_num_single_child_families`
+        ) * 100
+      ) AS FLOAT64),
+      2
+    )
+  ) AS `percent change`
+FROM `t30206548` AS `t30206548`
+ORDER BY
+  ABS(`percent_change`) DESC
+LIMIT 5
+```
+```python
+>>> print(df.sql(optimize=False))
+WITH t14183493 AS (
+  SELECT
+    `source_year`,
+    `year`,
+    `month`,
+    `day`,
+    `wday`,
+    `state`,
+    `is_male`,
+    `child_race`,
+    `weight_pounds`,
+    `plurality`,
+    `apgar_1min`,
+    `apgar_5min`,
+    `mother_residence_state`,
+    `mother_race`,
+    `mother_age`,
+    `gestation_weeks`,
+    `lmp`,
+    `mother_married`,
+    `mother_birth_state`,
+    `cigarette_use`,
+    `cigarettes_per_day`,
+    `alcohol_use`,
+    `drinks_per_week`,
+    `weight_gain_pounds`,
+    `born_alive_alive`,
+    `born_alive_dead`,
+    `born_dead`,
+    `ever_born`,
+    `father_race`,
+    `father_age`,
+    `record_weight`
+  FROM bigquery-public-data.samples.natality
+), t17633417 AS (
+  SELECT
+    year,
+    COUNT(*) AS num_single_child_families
+  FROM t14183493
+  WHERE
+    ever_born = 1
+  GROUP BY
+    year
+), t32066970 AS (
+  SELECT
+    year,
+    num_single_child_families,
+    LAG(num_single_child_families, 1) OVER (ORDER BY year) AS last_year_num_single_child_families
+  FROM t17633417
+), t21362690 AS (
+  SELECT
+    year,
+    num_single_child_families,
+    last_year_num_single_child_families,
+    (
+      (
+        num_single_child_families - last_year_num_single_child_families
+      ) / last_year_num_single_child_families
+    ) AS percent_change
+  FROM t32066970
+  ORDER BY
+    ABS(percent_change) DESC
+)
+SELECT
+  year AS year,
+  FORMAT('%\'.0f', ROUND(CAST(num_single_child_families AS FLOAT64), 0)) AS `new families single child`,
+  FORMAT('%\'.2f', ROUND(CAST((
+    percent_change * 100
+  ) AS FLOAT64), 2)) AS `percent change`
+FROM t21362690
+LIMIT 5
+```
+
+### Override Dialect
+
+The dialect of the generated SQL will be based on the session's dialect. However, you can override the dialect by passing a string to the `dialect` parameter. This is useful when you want to generate SQL for a different database.
+
+```python
+# create session and `df` like normal
+df.sql(dialect="bigquery")
+```
+
+### OpenAI Enrichment
+
+OpenAI's models can be used to enrich the generated SQL to make it more human-like.
+You can have it just provide more readable CTE names or you can have it try to make the whole SQL statement more readable.
+
+#### Example
+
+```python
+# create session and `df` like normal
+# The model to use defaults to `gpt-4o` but can be changed by passing a string to the `openai_model` parameter.
+>>> df.sql(openai_config={"mode": "cte_only", "model": "gpt-3.5-turbo"})
+WITH `single_child_families_by_year` AS (
+  SELECT
+    `natality`.`year` AS `year`,
+    COUNT(*) AS `num_single_child_families`
+  FROM `bigquery-public-data`.`samples`.`natality` AS `natality`
+  WHERE
+    `natality`.`ever_born` = 1
+  GROUP BY
+    `natality`.`year`
+), `families_with_percent_change` AS (
+  SELECT
+    `single_child_families_by_year`.`year` AS `year`,
+    `single_child_families_by_year`.`num_single_child_families` AS `num_single_child_families`,
+    LAG(`single_child_families_by_year`.`num_single_child_families`, 1) OVER (ORDER BY `single_child_families_by_year`.`year`) AS `last_year_num_single_child_families`
+  FROM `single_child_families_by_year` AS `single_child_families_by_year`
+)
+SELECT
+  `families_with_percent_change`.`year` AS `year`,
+  FORMAT('%\'.0f', ROUND(CAST(`families_with_percent_change`.`num_single_child_families` AS FLOAT64), 0)) AS `new families single child`,
+  FORMAT(
+    '%\'.2f',
+    ROUND(
+      CAST((
+        (
+          (
+            `families_with_percent_change`.`num_single_child_families` - `families_with_percent_change`.`last_year_num_single_child_families`
+          ) / `families_with_percent_change`.`last_year_num_single_child_families`
+        ) * 100
+      ) AS FLOAT64),
+      2
+    )
+  ) AS `percent change`
+FROM `families_with_percent_change` AS `families_with_percent_change`
+ORDER BY
+  ABS(`percent_change`) DESC
+LIMIT 5
+```
+
+#### Parameters
+
+| Parameter         | Description                                                           | Default    |
+|-------------------|-----------------------------------------------------------------------|------------|
+| `mode`            | The mode to use. Can be `cte_only` or `full`.                         | `cte_only` |
+| `model`           | The OpenAI model to use. Note: The default may change in new releases | `gpt-4o`   |
+| `prompt_override` | A string to use to override the default prompt.                       | None       |

{sqlframe-1.2.0 → sqlframe-1.4.0}/mkdocs.yml

@@ -7,6 +7,7 @@ nav:
   - "DuckDB": duckdb.md
   - "Postgres": postgres.md
   - "Standalone": standalone.md
+  - "Configuration": configuration.md
 theme:
   name: material
   logo: images/SF.png

{sqlframe-1.2.0 → sqlframe-1.4.0}/setup.py

@@ -26,11 +26,11 @@ setup(
         "bigquery": [
             "google-cloud-bigquery[pandas]>=3,<4",
             "google-cloud-bigquery-storage>=2,<3",
-            "pandas>=2,<3",
         ],
         "dev": [
             "duckdb>=0.9,<0.11",
             "mypy>=1.10.0,<1.11",
+            "openai>=1.30,<1.31",
             "pandas>=2,<3",
             "pandas-stubs>=2,<3",
             "psycopg>=3.1,<4",
@@ -56,17 +56,20 @@ setup(
             "duckdb>=0.9,<0.11",
             "pandas>=2,<3",
         ],
-        "postgres": [
+        "openai": [
+            "openai>=1.30,<1.31",
+        ],
+        "pandas": [
             "pandas>=2,<3",
+        ],
+        "postgres": [
             "psycopg2>=2.8,<3",
         ],
         "redshift": [
-            "pandas>=2,<3",
             "redshift_connector>=2.1.1,<2.2.0",
         ],
         "snowflake": [
-            "pandas>=2,<3",
-            "snowflake-connector-python[pandas,secure-local-storage]>=3.10.0,<3.11",
+            "snowflake-connector-python[secure-local-storage]>=3.10.0,<3.11",
         ],
         "spark": [
             "pyspark>=2,<3.6",

{sqlframe-1.2.0 → sqlframe-1.4.0}/sqlframe/_version.py

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

{sqlframe-1.2.0 → sqlframe-1.4.0}/sqlframe/base/column.py

@@ -9,9 +9,11 @@ import typing as t
 import sqlglot
 from sqlglot import expressions as exp
 from sqlglot.helper import flatten, is_iterable
+from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 
+from sqlframe.base.decorators import normalize
 from sqlframe.base.types import DataType
-from sqlframe.base.util import get_func_from_session
+from sqlframe.base.util import get_func_from_session, quote_preserving_alias_or_name
 
 if t.TYPE_CHECKING:
     from sqlframe.base._typing import ColumnOrLiteral, ColumnOrName
@@ -237,7 +239,7 @@ class Column:
 
     @property
     def alias_or_name(self) -> str:
-        return self.expression.alias_or_name
+        return quote_preserving_alias_or_name(self.expression)  # type: ignore
 
     @classmethod
     def ensure_literal(cls, value) -> Column:
@@ -266,7 +268,9 @@ class Column:
         from sqlframe.base.session import _BaseSession
 
         dialect = _BaseSession().input_dialect
-        alias: exp.Expression = exp.parse_identifier(name, dialect=dialect)
+        alias: exp.Expression = normalize_identifiers(
+            exp.parse_identifier(name, dialect=dialect), dialect=dialect
+        )
         new_expression = exp.Alias(
             this=self.column_expression,
             alias=alias.this if isinstance(alias, exp.Column) else alias,

{sqlframe-1.2.0 → sqlframe-1.4.0}/sqlframe/base/dataframe.py

@@ -2,26 +2,34 @@
 
 from __future__ import annotations
 
+import enum
 import functools
 import itertools
+import json
 import logging
 import sys
 import typing as t
 import zlib
 from copy import copy
+from dataclasses import dataclass
 
 import sqlglot
 from prettytable import PrettyTable
 from sqlglot import Dialect
 from sqlglot import expressions as exp
 from sqlglot.helper import ensure_list, object_to_dict, seq_get
+from sqlglot.optimizer.pushdown_projections import pushdown_projections
+from sqlglot.optimizer.qualify import qualify
 from sqlglot.optimizer.qualify_columns import quote_identifiers
 
+from sqlframe.base.decorators import normalize
 from sqlframe.base.operations import Operation, operation
 from sqlframe.base.transforms import replace_id_value
 from sqlframe.base.util import (
     get_func_from_session,
     get_tables_from_expression_with_join,
+    quote_preserving_alias_or_name,
+    verify_openai_installed,
 )
 
 if sys.version_info >= (3, 11):
@@ -70,6 +78,46 @@ JOIN_HINTS = {
 DF = t.TypeVar("DF", bound="_BaseDataFrame")
 
 
+class OpenAIMode(enum.Enum):
+    CTE_ONLY = "cte_only"
+    FULL = "full"
+
+    @property
+    def is_cte_only(self) -> bool:
+        return self == OpenAIMode.CTE_ONLY
+
+    @property
+    def is_full(self) -> bool:
+        return self == OpenAIMode.FULL
+
+
+@dataclass
+class OpenAIConfig:
+    mode: OpenAIMode = OpenAIMode.CTE_ONLY
+    model: str = "gpt-4o"
+    prompt_override: t.Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, config: t.Dict[str, t.Any]) -> OpenAIConfig:
+        if "mode" in config:
+            config["mode"] = OpenAIMode(config["mode"].lower())
+        return cls(**config)
+
+    def get_prompt(self, dialect: Dialect) -> str:
+        if self.prompt_override:
+            return self.prompt_override
+        if self.mode.is_cte_only:
+            return f"You are a backend tool that creates unique CTE alias names match what a human would write and in snake case. You respond without code blocks and only a json payload with the key being the CTE name that is being replaced and the value being the new CTE human readable name."
+        return f"""
+        You are a backend tool that converts correct {dialect} SQL to simplified and more human readable version.
+        You respond without code block with rewritten {dialect} SQL.
+        You don't change any column names in the final select because the user expects those to remain the same.
+        You make unique CTE alias names match what a human would write and in snake case.
+        You improve formatting with spacing and line-breaks.
+        You remove redundant parenthesis and aliases.
+        When remove extra quotes, make sure to keep quotes around words that could be reserved words"""
+
+
 class _BaseDataFrameNaFunctions(t.Generic[DF]):
     def __init__(self, df: DF):
         self.df = df
@@ -410,7 +458,7 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
 
         outer_select = item.find(exp.Select)
         if outer_select:
-            return [col(x.alias_or_name) for x in outer_select.expressions]
+            return [col(quote_preserving_alias_or_name(x)) for x in outer_select.expressions]
         return []
 
     def _create_hash_from_expression(self, expression: exp.Expression) -> str:
@@ -471,6 +519,7 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         dialect: DialectType = None,
         optimize: bool = True,
         pretty: bool = True,
+        openai_config: t.Optional[t.Union[t.Dict[str, t.Any], OpenAIConfig]] = None,
         as_list: bool = False,
         **kwargs,
     ) -> t.Union[str, t.List[str]]:
@@ -480,6 +529,11 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         select_expressions = df._get_select_expressions()
         output_expressions: t.List[t.Union[exp.Select, exp.Cache, exp.Drop]] = []
         replacement_mapping: t.Dict[exp.Identifier, exp.Identifier] = {}
+        openai_config = (
+            OpenAIConfig.from_dict(openai_config)
+            if openai_config is not None and isinstance(openai_config, dict)
+            else openai_config
+        )
 
         for expression_type, select_expression in select_expressions:
             select_expression = select_expression.transform(
@@ -490,6 +544,9 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
                 select_expression = t.cast(
                     exp.Select, self.session._optimize(select_expression, dialect=dialect)
                 )
+            elif openai_config:
+                qualify(select_expression, dialect=dialect, schema=self.session.catalog._schema)
+                pushdown_projections(select_expression, schema=self.session.catalog._schema)
 
             select_expression = df._replace_cte_names_with_hashes(select_expression)
 
@@ -505,7 +562,9 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
                 self.session.catalog.add_table(
                     cache_table_name,
                     {
-                        expression.alias_or_name: expression.type.sql(dialect=dialect)
+                        quote_preserving_alias_or_name(expression): expression.type.sql(
+                            dialect=dialect
+                        )
                         if expression.type
                         else "UNKNOWN"
                         for expression in select_expression.expressions
@@ -541,10 +600,37 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
 
             output_expressions.append(expression)
 
-        results = [
-            expression.sql(dialect=dialect, pretty=pretty, **kwargs)
-            for expression in output_expressions
-        ]
+        results = []
+        for expression in output_expressions:
+            sql = expression.sql(dialect=dialect, pretty=pretty, **kwargs)
+            if openai_config:
+                assert isinstance(openai_config, OpenAIConfig)
+                verify_openai_installed()
+                from openai import OpenAI
+
+                client = OpenAI()
+                chat_completed = client.chat.completions.create(
+                    messages=[
+                        {  # type: ignore
+                            "role": "system",
+                            "content": openai_config.get_prompt(dialect),
+                        },
+                        {
+                            "role": "user",
+                            "content": sql,
+                        },
+                    ],
+                    model=openai_config.model,
+                )
+                assert chat_completed.choices[0].message.content is not None
+                if openai_config.mode.is_cte_only:
+                    cte_replacement_mapping = json.loads(chat_completed.choices[0].message.content)
+                    for old_name, new_name in cte_replacement_mapping.items():
+                        sql = sql.replace(old_name, new_name)
+                else:
+                    sql = chat_completed.choices[0].message.content
+            results.append(sql)
+
         if as_list:
             return results
         return ";\n".join(results)
@@ -688,7 +774,7 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         join_expression = self._add_ctes_to_expression(join_expression, other_df.expression.ctes)
         self_columns = self._get_outer_select_columns(join_expression)
         other_columns = self._get_outer_select_columns(other_df.expression)
-        join_columns = self._ensure_list_of_columns(on)
+        join_columns = self._ensure_and_normalize_cols(on)
         # Determines the join clause and select columns to be used passed on what type of columns were provided for
         # the join. The columns returned changes based on how the on expression is provided.
         if how != "cross":
@@ -1324,6 +1410,7 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         assert sqls[-1] is not None
         return self.session._fetchdf(sqls[-1])
 
+    @normalize("name")
     def createOrReplaceTempView(self, name: str) -> None:
         self.session.temp_views[name] = self.copy()._convert_leaf_to_cte()
 

sqlframe-1.4.0/sqlframe/base/decorators.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import functools
+import typing as t
+
+from sqlglot import parse_one
+from sqlglot.helper import ensure_list
+from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
+
+if t.TYPE_CHECKING:
+    from sqlframe.base.catalog import _BaseCatalog
+
+CALLING_CLASS = t.TypeVar("CALLING_CLASS")
+
+
+def normalize(normalize_kwargs: t.Union[str, t.List[str]]) -> t.Callable[[t.Callable], t.Callable]:
+    """
+    Decorator used to normalize identifiers in the kwargs of a method.
+    """
+
+    def decorator(func: t.Callable) -> t.Callable:
+        @functools.wraps(func)
+        def wrapper(self: CALLING_CLASS, *args, **kwargs) -> CALLING_CLASS:
+            from sqlframe.base.session import _BaseSession
+
+            input_dialect = _BaseSession().input_dialect
+            kwargs.update(dict(zip(func.__code__.co_varnames[1:], args)))
+            for kwarg in ensure_list(normalize_kwargs):
+                if kwarg in kwargs:
+                    value = kwargs.get(kwarg)
+                    if value:
+                        expression = (
+                            parse_one(value, dialect=input_dialect)
+                            if isinstance(value, str)
+                            else value
+                        )
+                        kwargs[kwarg] = normalize_identifiers(expression, input_dialect).sql(
+                            dialect=input_dialect
+                        )
+            return func(self, **kwargs)
+
+        wrapper.__wrapped__ = func  # type: ignore
+        return wrapper
+
+    return decorator
+
+
+def func_metadata(unsupported_engines: t.Optional[t.Union[str, t.List[str]]] = None) -> t.Callable:
+    def _metadata(func: t.Callable) -> t.Callable:
+        func.unsupported_engines = ensure_list(unsupported_engines) if unsupported_engines else []  # type: ignore
+        return func
+
+    return _metadata