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

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/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/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/base/decorators.py

@@ -10,31 +10,33 @@ 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.List[str]) -> t.Callable[[t.Callable], t.Callable]:
+
+def normalize(normalize_kwargs: t.Union[str, t.List[str]]) -> t.Callable[[t.Callable], t.Callable]:
     """
-    Decorator used around DataFrame methods to indicate what type of operation is being performed from the
-    ordered Operation enums. This is used to determine which operations should be performed on a CTE vs.
-    included with the previous operation.
-
-    Ex: After a user does a join we want to allow them to select which columns for the different
-    tables that they want to carry through to the following operation. If we put that join in
-    a CTE preemptively then the user would not have a chance to select which column they want
-    in cases where there is overlap in names.
+    Decorator used to normalize identifiers in the kwargs of a method.
     """
 
     def decorator(func: t.Callable) -> t.Callable:
         @functools.wraps(func)
-        def wrapper(self: _BaseCatalog, *args, **kwargs) -> _BaseCatalog:
+        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 normalize_kwargs:
+            for kwarg in ensure_list(normalize_kwargs):
                 if kwarg in kwargs:
                     value = kwargs.get(kwarg)
                     if value:
-                        expression = parse_one(value, dialect=self.session.input_dialect)
-                        kwargs[kwarg] = normalize_identifiers(
-                            expression, self.session.input_dialect
-                        ).sql(dialect=self.session.input_dialect)
+                        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

sqlframe/base/mixins/catalog_mixins.py

@@ -13,7 +13,7 @@ from sqlframe.base.catalog import (
     _BaseCatalog,
 )
 from sqlframe.base.decorators import normalize
-from sqlframe.base.util import decoded_str, schema_, to_schema
+from sqlframe.base.util import schema_, to_schema
 
 
 class _BaseInfoSchemaMixin(_BaseCatalog, t.Generic[SESSION, DF]):

sqlframe/base/mixins/readwriter_mixins.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 import pathlib
 import typing as t
 
-import pandas as pd
-
 from sqlframe.base.exceptions import UnsupportedOperationError
 from sqlframe.base.readerwriter import (
     DF,
@@ -13,7 +11,7 @@ from sqlframe.base.readerwriter import (
     _BaseDataFrameWriter,
     _infer_format,
 )
-from sqlframe.base.util import pandas_to_spark_schema
+from sqlframe.base.util import pandas_to_spark_schema, verify_pandas_installed
 
 if t.TYPE_CHECKING:
     from sqlframe.base._typing import OptionalPrimitiveType, PathOrPaths
@@ -72,6 +70,9 @@ class PandasLoaderMixin(_BaseDataFrameReader, t.Generic[SESSION, DF]):
         |100|NULL|
         +---+----+
         """
+        verify_pandas_installed()
+        import pandas as pd
+
         assert path is not None, "path is required"
         assert isinstance(path, str), "path must be a string"
         format = format or _infer_format(path)

sqlframe/base/readerwriter.py

@@ -11,6 +11,8 @@ from functools import reduce
 from sqlglot import exp
 from sqlglot.helper import object_to_dict
 
+from sqlframe.base.decorators import normalize
+
 if sys.version_info >= (3, 11):
     from typing import Self
 else:
@@ -39,6 +41,7 @@ class _BaseDataFrameReader(t.Generic[SESSION, DF]):
     def session(self) -> SESSION:
         return self._session
 
+    @normalize("tableName")
     def table(self, tableName: str) -> DF:
         if df := self.session.temp_views.get(tableName):
             return df

sqlframe/base/session.py

@@ -24,7 +24,10 @@ from sqlglot.schema import MappingSchema
 from sqlframe.base.catalog import _BaseCatalog
 from sqlframe.base.dataframe import _BaseDataFrame
 from sqlframe.base.readerwriter import _BaseDataFrameReader, _BaseDataFrameWriter
-from sqlframe.base.util import get_column_mapping_from_schema_input
+from sqlframe.base.util import (
+    get_column_mapping_from_schema_input,
+    verify_pandas_installed,
+)
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -412,6 +415,7 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, CONN]):
         self, expression: exp.Expression, dialect: t.Optional[Dialect] = None
     ) -> exp.Expression:
         dialect = dialect or self.output_dialect
+        normalize_identifiers(expression, dialect=self.input_dialect)
         quote_identifiers_func(expression, dialect=dialect)
         return optimize(expression, dialect=dialect, schema=self.catalog._schema)
 
@@ -446,14 +450,6 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, CONN]):
     def _fetch_rows(
         self, sql: t.Union[str, exp.Expression], *, quote_identifiers: bool = True
     ) -> t.List[Row]:
-        from sqlframe.base.types import Row
-
-        def _dict_to_row(row: t.Dict[str, t.Any]) -> Row:
-            for key, value in row.items():
-                if isinstance(value, dict):
-                    row[key] = _dict_to_row(value)
-            return Row(**row)
-
         self._execute(sql, quote_identifiers=quote_identifiers)
         result = self._cur.fetchall()
         if not self._cur.description:
@@ -464,6 +460,7 @@ class _BaseSession(t.Generic[CATALOG, READER, WRITER, DF, CONN]):
     def _fetchdf(
         self, sql: t.Union[str, exp.Expression], *, quote_identifiers: bool = True
     ) -> pd.DataFrame:
+        verify_pandas_installed()
         from pandas.io.sql import read_sql_query
 
         return read_sql_query(self._to_sql(sql, quote_identifiers=quote_identifiers), self._conn)

sqlframe/base/util.py

@@ -154,7 +154,12 @@ def pandas_to_spark_schema(pandas_df: PandasDataFrame) -> types.StructType:
     """
     from sqlframe.base import types
 
-    columns = list([x.replace("?column?", "unknown_column") for x in pandas_df.columns])
+    columns = list(
+        [
+            x.replace("?column?", f"unknown_column_{i}").replace("NULL", f"unknown_column_{i}")
+            for i, x in enumerate(pandas_df.columns)
+        ]
+    )
     d_types = list(pandas_df.dtypes)
     p_schema = types.StructType(
         [
@@ -240,3 +245,35 @@ def soundex(s):
 
     result += "0" * (4 - count)
     return "".join(result)
+
+
+def verify_pandas_installed():
+    try:
+        import pandas  # noqa
+    except ImportError:
+        raise ImportError(
+            """Pandas is required for this functionality. `pip install "sqlframe[pandas]"` (also include your engine if needed) to install pandas."""
+        )
+
+
+def verify_openai_installed():
+    try:
+        import openai  # noqa
+    except ImportError:
+        raise ImportError(
+            """OpenAI is required for this functionality. `pip install "sqlframe[openai]"` (also include your engine if needed) to install openai."""
+        )
+
+
+def quote_preserving_alias_or_name(col: t.Union[exp.Column, exp.Alias]) -> str:
+    from sqlframe.base.session import _BaseSession
+
+    if isinstance(col, exp.Alias):
+        col = col.args["alias"]
+    if isinstance(col, exp.Column):
+        col = col.copy()
+        col.set("table", None)
+    if isinstance(col, (exp.Identifier, exp.Column)):
+        return col.sql(dialect=_BaseSession().input_dialect)
+    # We may get things like `Null()` expression or maybe literals so we just return the alias or name in those cases
+    return col.alias_or_name

sqlframe/snowflake/catalog.py

@@ -127,7 +127,9 @@ class SnowflakeCatalog(
         sql = f"SHOW COLUMNS IN TABLE {table.sql(dialect=self.session.input_dialect)}"
         results = self.session._fetch_rows(sql)
         return {
-            row["column_name"]: exp.DataType.build(
+            exp.column(row["column_name"], quoted=True).sql(
+                dialect=self.session.input_dialect
+            ): exp.DataType.build(
                 json.loads(row["data_type"])["type"], dialect=self.session.input_dialect, udt=True
             )
             for row in results

sqlframe/snowflake/session.py

@@ -1,8 +1,14 @@
 from __future__ import annotations
 
+import json
 import typing as t
 import warnings
 
+try:
+    from snowflake.connector.converter import SnowflakeConverter
+except ImportError:
+    SnowflakeConverter = object  # type: ignore
+
 from sqlframe.base.session import _BaseSession
 from sqlframe.snowflake.catalog import SnowflakeCatalog
 from sqlframe.snowflake.dataframe import SnowflakeDataFrame
@@ -17,6 +23,18 @@ else:
     SnowflakeConnection = t.Any
 
 
+class JsonLoadsSnowflakeConverter(SnowflakeConverter):
+    def _json_loads(self, ctx: dict[str, t.Any]) -> t.Callable:
+        def conv(value: str) -> t.List:
+            return json.loads(value)
+
+        return conv
+
+    _OBJECT_to_python = _json_loads  # type: ignore
+    _VARIANT_to_python = _json_loads  # type: ignore
+    _ARRAY_to_python = _json_loads  # type: ignore
+
+
 class SnowflakeSession(
     _BaseSession[  # type: ignore
         SnowflakeCatalog,
@@ -35,8 +53,21 @@ class SnowflakeSession(
         warnings.warn(
             "SnowflakeSession is still in active development. Functions may not work as expected."
         )
+        import snowflake
+
+        snowflake.connector.cursor.CAN_USE_ARROW_RESULT_FORMAT = False
+
         if not hasattr(self, "_conn"):
             super().__init__(conn)
+            if self._conn.converter and not isinstance(
+                self._conn.converter, JsonLoadsSnowflakeConverter
+            ):
+                self._conn.converter = JsonLoadsSnowflakeConverter(
+                    use_numpy=self._conn._numpy,
+                    support_negative_year=self._conn._support_negative_year,
+                )
+            else:
+                self._conn._converter_class = JsonLoadsSnowflakeConverter  # type: ignore
 
     class Builder(_BaseSession.Builder):
         DEFAULT_INPUT_DIALECT = "snowflake"

sqlframe/spark/session.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import typing as t
 import warnings
 
-import pandas as pd
 from sqlglot import exp
 
 from sqlframe.base.session import _BaseSession
@@ -15,6 +14,9 @@ from sqlframe.spark.readwriter import (
 )
 from sqlframe.spark.types import Row
 
+if t.TYPE_CHECKING:
+    import pandas as pd
+
 
 class SparkSession(
     _BaseSession[  # type: ignore

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

@@ -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
@@ -22,10 +22,10 @@ Requires-Dist: sqlglot (<24.1,>=24.0.0)
 Provides-Extra: bigquery
 Requires-Dist: google-cloud-bigquery-storage (<3,>=2) ; extra == 'bigquery'
 Requires-Dist: google-cloud-bigquery[pandas] (<4,>=3) ; extra == 'bigquery'
-Requires-Dist: pandas (<3,>=2) ; extra == 'bigquery'
 Provides-Extra: dev
 Requires-Dist: duckdb (<0.11,>=0.9) ; extra == 'dev'
 Requires-Dist: mypy (<1.11,>=1.10.0) ; extra == 'dev'
+Requires-Dist: openai (<1.31,>=1.30) ; extra == 'dev'
 Requires-Dist: pandas-stubs (<3,>=2) ; extra == 'dev'
 Requires-Dist: pandas (<3,>=2) ; extra == 'dev'
 Requires-Dist: psycopg (<4,>=3.1) ; extra == 'dev'
@@ -48,32 +48,33 @@ Requires-Dist: pymdown-extensions ; extra == 'docs'
 Provides-Extra: duckdb
 Requires-Dist: duckdb (<0.11,>=0.9) ; extra == 'duckdb'
 Requires-Dist: pandas (<3,>=2) ; extra == 'duckdb'
+Provides-Extra: openai
+Requires-Dist: openai (<1.31,>=1.30) ; extra == 'openai'
+Provides-Extra: pandas
+Requires-Dist: pandas (<3,>=2) ; extra == 'pandas'
 Provides-Extra: postgres
-Requires-Dist: pandas (<3,>=2) ; extra == 'postgres'
 Requires-Dist: psycopg2 (<3,>=2.8) ; extra == 'postgres'
 Provides-Extra: redshift
-Requires-Dist: pandas (<3,>=2) ; extra == 'redshift'
 Requires-Dist: redshift-connector (<2.2.0,>=2.1.1) ; extra == 'redshift'
 Provides-Extra: snowflake
-Requires-Dist: pandas (<3,>=2) ; extra == 'snowflake'
-Requires-Dist: snowflake-connector-python[pandas,secure-local-storage] (<3.11,>=3.10.0) ; extra == 'snowflake'
+Requires-Dist: snowflake-connector-python[secure-local-storage] (<3.11,>=3.10.0) ; extra == 'snowflake'
 Provides-Extra: spark
 Requires-Dist: pyspark (<3.6,>=2) ; extra == 'spark'
 
 <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:
 
@@ -96,6 +97,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.dist-info → sqlframe-1.4.0.dist-info}/RECORD

@@ -1,27 +1,27 @@
 sqlframe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlframe/_version.py,sha256=zMnMemknXglcJs59xkicNzeEJTVgYd1omSfLWj76yWw,411
+sqlframe/_version.py,sha256=R8-T9fmURjcuoxYpHTAjyNAhgJPDtI2jogCjqYYkfCU,411
 sqlframe/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlframe/base/_typing.py,sha256=DuTay8-o9W-pw3RPZCgLunKNJLS9PkaV11G_pxXp9NY,1256
 sqlframe/base/catalog.py,sha256=ATDGirouUjal05P4ymL-wIi8rgjg_8w4PoACamiO64A,37245
-sqlframe/base/column.py,sha256=1xFwPhBlzdO6ZL9tTpPESL7B3XQ3rFMPIoBekFm0TqM,15109
-sqlframe/base/dataframe.py,sha256=cFaJupLZflakMfwcR_KsrxtinV8ZckRZGRjWzx1vBs8,59136
-sqlframe/base/decorators.py,sha256=fnqT1Hqa0J_gUurDcVY1Dcscj6SXFxFJ5PKAw-xe5sU,2097
+sqlframe/base/column.py,sha256=p3VrtATBmjAYHollFcsdps2UJTNC-Pvyg4Zt7y4CK9w,15358
+sqlframe/base/dataframe.py,sha256=9PuqC9dBficSE-Y1v_BHyk4gK-Hd43SaVBmxBeyNnD8,62939
+sqlframe/base/decorators.py,sha256=I5osMgx9BuCgbtp4jVM2DNwYJVLzCv-OtTedhQEik0g,1882
 sqlframe/base/exceptions.py,sha256=pCB9hXX4jxZWzNg3JN1i38cv3BmpUlee5NoLYx3YXIQ,208
 sqlframe/base/function_alternatives.py,sha256=to0kv3MTJmQFeVTMcitz0AxBIoUJC3cu5LkEY5aJpoo,31318
 sqlframe/base/functions.py,sha256=iVe8AbXGX_gXnkQ1N-clX6rihsonfzJ84_YvWzhB2FM,53540
 sqlframe/base/group.py,sha256=TES9CleVmH3x-0X-tqmuUKfCKSWjH5vg1aU3R6dDmFc,4059
 sqlframe/base/normalize.py,sha256=gRBn-PziFdE-CHtPJMkMl7y_YH0mauUcD4zfgyyvlpw,3565
 sqlframe/base/operations.py,sha256=-AhNuEzcV7ZExoP1oY3blaKip-joQyJeQVvfBTs_2g4,3456
-sqlframe/base/readerwriter.py,sha256=kyPdmOmi75lHsEAkmHOq9wsLj2cGWf0oHwngwkZYx8k,25212
-sqlframe/base/session.py,sha256=s-jnViqdO6E4t8KiHIiUIBa1mxQlhlSb0dBPUl42nbI,21925
+sqlframe/base/readerwriter.py,sha256=5NPQMiOrw6I54U243R_6-ynnWYsNksgqwRpPp4IFjIw,25288
+sqlframe/base/session.py,sha256=-h7qcOPRw9KBJPg_V6Tlr8Z2SmcsgAWruBo34o6zfrQ,21795
 sqlframe/base/transforms.py,sha256=y0j3SGDz3XCmNGrvassk1S-owllUWfkHyMgZlY6SFO4,467
 sqlframe/base/types.py,sha256=aJT5YXr-M_LAfUM0uK4asfbrQFab_xmsp1CP2zkG8p0,11924
-sqlframe/base/util.py,sha256=SeUC2pcSBGnsS1W5PL1p-IGC6bJG8_2a7En2hxSTmpA,7597
+sqlframe/base/util.py,sha256=wdATi7STt-FfXrX9TPRkw4PFJP7uAsK_K9YkKSrd0qU,8824
 sqlframe/base/window.py,sha256=8hOv-ignPPIsZA9FzvYzcLE9J_glalVaYjIAUdRUX3o,4943
 sqlframe/base/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlframe/base/mixins/catalog_mixins.py,sha256=arO9psYkFULnRi2-3XnnWJBYf_nwbU52fa0nEaRU4aE,14225
+sqlframe/base/mixins/catalog_mixins.py,sha256=NhuPGxIqPjyuC_V_NALN1sn9v9h0-xwFOlJyJgsvyek,14212
 sqlframe/base/mixins/dataframe_mixins.py,sha256=U2tKIY5pCLnoPy1boAQ1YWLgK1E-ZT4x47oRWtGoYLQ,2360
-sqlframe/base/mixins/readwriter_mixins.py,sha256=N2nsXOG3A2j6O3N195U-_fYOZMkqfifGcfduxODUcxs,4656
+sqlframe/base/mixins/readwriter_mixins.py,sha256=QnxGVL8ftZfYlBNG0Bl24N_bnA2YioSxUsTSgKIbuvQ,4723
 sqlframe/bigquery/__init__.py,sha256=i2NsMbiXOj2xphCtPuNk6cVw4iYeq5_B1I9dVI9aGAk,712
 sqlframe/bigquery/catalog.py,sha256=h3aQAQAJg6MMvFpP8Ku0S4pcx30n5qYrqHhWSomxb6A,9319
 sqlframe/bigquery/column.py,sha256=E1tUa62Y5HajkhgFuebU9zohrGyieudcHzTT8gfalio,40
@@ -63,13 +63,13 @@ sqlframe/redshift/session.py,sha256=GA2CFGJckissPYmcXWR1R3QOOoSa9XuLOR6sWFFuC1k,
 sqlframe/redshift/types.py,sha256=KwNyuXIo-2xVVd4bZED3YrQOobKCtemlxGrJL7DrTC8,34
 sqlframe/redshift/window.py,sha256=6GKPzuxeSapJakBaKBeT9VpED1ACdjggDv9JRILDyV0,35
 sqlframe/snowflake/__init__.py,sha256=nuQ3cuHjDpW4ELZfbd2qOYmtXmcYl7MtsrdOrRdozo0,746
-sqlframe/snowflake/catalog.py,sha256=1Mu6pgYF3CIJwhgrHpYE_mMbg8Mg5m5N-rrglQHMWP0,4919
+sqlframe/snowflake/catalog.py,sha256=uDjBgDdCyxaDkGNX_8tb-lol7MwwazcClUBAZsOSj70,5014
 sqlframe/snowflake/column.py,sha256=E1tUa62Y5HajkhgFuebU9zohrGyieudcHzTT8gfalio,40
 sqlframe/snowflake/dataframe.py,sha256=OJ27NudBUE3XX9mc8ywooGhYV4ijF9nX2K_nkHRcTx4,1393
 sqlframe/snowflake/functions.py,sha256=ZYX9gyPvmpKoLi_7uQdB0uPQNTREOAJD0aCcccX1iPc,456
 sqlframe/snowflake/group.py,sha256=pPP1l2RRo_LgkXrji8a87n2PKo-63ZRPT-WUtvVcBME,395
 sqlframe/snowflake/readwriter.py,sha256=yhRc2HcMq6PwV3ghZWC-q-qaE7LE4aEjZEXCip4OOlQ,884
-sqlframe/snowflake/session.py,sha256=oJK_3t43TeUiAj7KBfn2lD5d6AVHWsI39xLu-j_h5QM,1502
+sqlframe/snowflake/session.py,sha256=QKdxXgK9_YgxoyxzEd73ot4t0M6Dz4em09JdVMYxVPI,2584
 sqlframe/snowflake/types.py,sha256=KwNyuXIo-2xVVd4bZED3YrQOobKCtemlxGrJL7DrTC8,34
 sqlframe/snowflake/window.py,sha256=6GKPzuxeSapJakBaKBeT9VpED1ACdjggDv9JRILDyV0,35
 sqlframe/spark/__init__.py,sha256=jamKYQtQaKjjXnQ01QGPHvatbrZSw9sWno_VOUGSz6I,712
@@ -79,7 +79,7 @@ sqlframe/spark/dataframe.py,sha256=V3z5Bx9snLgYh4bDwJfJb5mj1P7UsZF8DMlLwZXopBg,1
 sqlframe/spark/functions.py,sha256=eSGMM2DXcj17nIPH5ZDLG95ZMuE7F8Qvn0IqGO_wQVw,586
 sqlframe/spark/group.py,sha256=MrvV_v-YkBc6T1zz882WrEqtWjlooWIyHBCmTQg3fCA,379
 sqlframe/spark/readwriter.py,sha256=w68EImTcGJv64X7pc1tk5tDjDxb1nAnn-MiIaaN9Dc8,812
-sqlframe/spark/session.py,sha256=EJWp4OEM0maGwuOF3YtHat-zXWVUeNlDa23tIoY1KbI,2603
+sqlframe/spark/session.py,sha256=D7gss1QGSvSLAF86WrLKvIbn0UC2YiMZnmVdCqv1SZA,2628
 sqlframe/spark/types.py,sha256=KwNyuXIo-2xVVd4bZED3YrQOobKCtemlxGrJL7DrTC8,34
 sqlframe/spark/window.py,sha256=6GKPzuxeSapJakBaKBeT9VpED1ACdjggDv9JRILDyV0,35
 sqlframe/standalone/__init__.py,sha256=yu4A97HwhyDwllDEzG7io4ScyWipWSAH2tqUKS545OA,767
@@ -92,8 +92,8 @@ sqlframe/standalone/readwriter.py,sha256=EZNyDJ4ID6sGNog3uP4-e9RvchX4biJJDNtc5hk
 sqlframe/standalone/session.py,sha256=wQmdu2sv6KMTAv0LRFk7TY7yzlh3xvmsyqilEtRecbY,1191
 sqlframe/standalone/types.py,sha256=KwNyuXIo-2xVVd4bZED3YrQOobKCtemlxGrJL7DrTC8,34
 sqlframe/standalone/window.py,sha256=6GKPzuxeSapJakBaKBeT9VpED1ACdjggDv9JRILDyV0,35
-sqlframe-1.2.0.dist-info/LICENSE,sha256=VZu79YgW780qxaFJMr0t5ZgbOYEh04xWoxaWOaqIGWk,1068
-sqlframe-1.2.0.dist-info/METADATA,sha256=KguQN7Rfbq_cqfdxvu28gdyMfisTRZ6-DVOCAt31Q2Y,6873
-sqlframe-1.2.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-sqlframe-1.2.0.dist-info/top_level.txt,sha256=T0_RpoygaZSF6heeWwIDQgaP0varUdSK1pzjeJZRjM8,9
-sqlframe-1.2.0.dist-info/RECORD,,
+sqlframe-1.4.0.dist-info/LICENSE,sha256=VZu79YgW780qxaFJMr0t5ZgbOYEh04xWoxaWOaqIGWk,1068
+sqlframe-1.4.0.dist-info/METADATA,sha256=nnz73ML6w8WyctFzwiaKVVNr9RQwmpmfckrcKqEX_PE,7219
+sqlframe-1.4.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+sqlframe-1.4.0.dist-info/top_level.txt,sha256=T0_RpoygaZSF6heeWwIDQgaP0varUdSK1pzjeJZRjM8,9
+sqlframe-1.4.0.dist-info/RECORD,,