sqlframe 1.1.3__tar.gz → 1.3.0__tar.gz

{sqlframe-1.1.3 → sqlframe-1.3.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.1.3 → sqlframe-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlframe
-Version: 1.1.3
+Version: 1.3.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

sqlframe-1.3.0/docs/configuration.md

@@ -0,0 +1,229 @@
+# 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 Enriched
+
+OpenAI's models can be used to enrich the generated SQL to make it more human-like. 
+This is useful when you want to generate SQL that is more readable for humans.
+You must have `OPENAI_API_KEY` set in your environment variables to use this feature.
+
+```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(optimize=False, use_openai=True)
+WITH natality_data AS (
+  SELECT
+    year,
+    ever_born
+  FROM `bigquery-public-data`.`samples`.`natality`
+), single_child_families AS (
+  SELECT
+    year,
+    COUNT(*) AS num_single_child_families
+  FROM natality_data
+  WHERE ever_born = 1
+  GROUP BY year
+), lagged_families 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 single_child_families
+), percent_change_families AS (
+  SELECT
+    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 lagged_families
+  ORDER BY ABS(percent_change) DESC
+)
+SELECT
+  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 percent_change_families
+LIMIT 5
+```

{sqlframe-1.1.3 → sqlframe-1.3.0}/docs/duckdb.md

@@ -171,6 +171,7 @@ df_store = session.createDataFrame(
 * [na](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.na.html)
 * [orderBy](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.orderBy.html)
 * [persist](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.persist.html)
+* [printSchema](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.printSchema.html)
 * [replace](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.replace.html)
 * [select](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.select.html)
 * [show](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.show.html)

{sqlframe-1.1.3 → sqlframe-1.3.0}/docs/postgres.md

@@ -174,6 +174,7 @@ df_store = session.createDataFrame(
 * [na](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.na.html)
 * [orderBy](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.orderBy.html)
 * [persist](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.persist.html)
+* [printSchema](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.printSchema.html)
 * [replace](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.replace.html)
 * [select](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.select.html)
 * [show](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.show.html)

{sqlframe-1.1.3 → sqlframe-1.3.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.1.3 → sqlframe-1.3.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.1.3 → sqlframe-1.3.0}/sqlframe/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.1.3'
-__version_tuple__ = version_tuple = (1, 1, 3)
+__version__ = version = '1.3.0'
+__version_tuple__ = version_tuple = (1, 3, 0)

{sqlframe-1.1.3 → sqlframe-1.3.0}/sqlframe/base/catalog.py

@@ -26,6 +26,9 @@ else:
 class _BaseCatalog(t.Generic[SESSION, DF]):
     """User-facing catalog API, accessible through `SparkSession.catalog`."""
 
+    TEMP_CATALOG_FILTER: t.Optional[exp.Expression] = None
+    TEMP_SCHEMA_FILTER: t.Optional[exp.Expression] = None
+
     def __init__(self, sparkSession: SESSION, schema: t.Optional[MappingSchema] = None) -> None:
         """Create a new Catalog that wraps the underlying JVM object."""
         self.session = sparkSession
@@ -569,7 +572,9 @@ class _BaseCatalog(t.Generic[SESSION, DF]):
         """
         raise NotImplementedError
 
-    def listColumns(self, tableName: str, dbName: t.Optional[str] = None) -> t.List[Column]:
+    def listColumns(
+        self, tableName: str, dbName: t.Optional[str] = None, include_temp: bool = False
+    ) -> t.List[Column]:
         """Returns a t.List of columns for the given table/view in the specified database.
 
         .. versionadded:: 2.0.0

{sqlframe-1.1.3 → sqlframe-1.3.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.1.3 → sqlframe-1.3.0}/sqlframe/base/dataframe.py

@@ -15,13 +15,18 @@ 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):
@@ -410,7 +415,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 +476,8 @@ class _BaseDataFrame(t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]):
         dialect: DialectType = None,
         optimize: bool = True,
         pretty: bool = True,
+        use_openai: bool = False,
+        openai_model: str = "gpt-4o",
         as_list: bool = False,
         **kwargs,
     ) -> t.Union[str, t.List[str]]:
@@ -490,6 +497,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 use_openai:
+                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 +515,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 +553,40 @@ 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 use_openai:
+                verify_openai_installed()
+                from openai import OpenAI
+
+                client = OpenAI()
+                prompt = 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
+                """
+                chat_completed = client.chat.completions.create(
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": prompt,
+                        },
+                        {
+                            "role": "user",
+                            "content": sql,
+                        },
+                    ],
+                    model=openai_model,
+                )
+                assert chat_completed.choices[0].message.content is not None
+                sql = chat_completed.choices[0].message.content
+            results.append(sql)
+
         if as_list:
             return results
         return ";\n".join(results)
@@ -688,7 +730,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 +1366,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.3.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

{sqlframe-1.1.3 → sqlframe-1.3.0}/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]):
@@ -315,7 +315,9 @@ class ListTablesFromInfoSchemaMixin(_BaseInfoSchemaMixin, t.Generic[SESSION, DF]
 
 class ListColumnsFromInfoSchemaMixin(_BaseInfoSchemaMixin, t.Generic[SESSION, DF]):
     @normalize(["tableName", "dbName"])
-    def listColumns(self, tableName: str, dbName: t.Optional[str] = None) -> t.List[Column]:
+    def listColumns(
+        self, tableName: str, dbName: t.Optional[str] = None, include_temp: bool = False
+    ) -> t.List[Column]:
         """Returns a t.List of columns for the given table/view in the specified database.
 
         .. versionadded:: 2.0.0
@@ -385,12 +387,6 @@ class ListColumnsFromInfoSchemaMixin(_BaseInfoSchemaMixin, t.Generic[SESSION, DF
                     "catalog",
                     exp.parse_identifier(self.currentCatalog(), dialect=self.session.input_dialect),
                 )
-        # if self.QUALIFY_INFO_SCHEMA_WITH_DATABASE:
-        #     if not table.db:
-        #         raise ValueError("dbName must be specified when listing columns from INFORMATION_SCHEMA")
-        #     source_table = f"{table.db}.INFORMATION_SCHEMA.COLUMNS"
-        # else:
-        #     source_table = "INFORMATION_SCHEMA.COLUMNS"
         source_table = self._get_info_schema_table("columns", database=table.db)
         select = (
             exp.select(
@@ -402,9 +398,15 @@ class ListColumnsFromInfoSchemaMixin(_BaseInfoSchemaMixin, t.Generic[SESSION, DF
             .where(exp.column("table_name").eq(table.name))
         )
         if table.db:
-            select = select.where(exp.column("table_schema").eq(table.db))
+            schema_filter: exp.Expression = exp.column("table_schema").eq(table.db)
+            if include_temp and self.TEMP_SCHEMA_FILTER:
+                schema_filter = exp.Or(this=schema_filter, expression=self.TEMP_SCHEMA_FILTER)
+            select = select.where(schema_filter)
         if table.catalog:
-            select = select.where(exp.column("table_catalog").eq(table.catalog))
+            catalog_filter: exp.Expression = exp.column("table_catalog").eq(table.catalog)
+            if include_temp and self.TEMP_CATALOG_FILTER:
+                catalog_filter = exp.Or(this=catalog_filter, expression=self.TEMP_CATALOG_FILTER)
+            select = select.where(catalog_filter)
         results = self.session._fetch_rows(select)
         return [
             Column(

sqlframe-1.3.0/sqlframe/base/mixins/dataframe_mixins.py

@@ -0,0 +1,63 @@
+import typing as t
+
+from sqlglot import exp
+
+from sqlframe.base.catalog import Column
+from sqlframe.base.dataframe import (
+    GROUP_DATA,
+    NA,
+    SESSION,
+    STAT,
+    WRITER,
+    _BaseDataFrame,
+)
+
+
+class PrintSchemaFromTempObjectsMixin(
+    _BaseDataFrame, t.Generic[SESSION, WRITER, NA, STAT, GROUP_DATA]
+):
+    def _get_columns_from_temp_object(self) -> t.List[Column]:
+        table = exp.to_table(self.session._random_id)
+        self.session._execute(
+            exp.Create(
+                this=table,
+                kind="VIEW",
+                replace=True,
+                properties=exp.Properties(expressions=[exp.TemporaryProperty()]),
+                expression=self.expression,
+            )
+        )
+        return self.session.catalog.listColumns(
+            table.sql(dialect=self.session.input_dialect), include_temp=True
+        )
+
+    def printSchema(self, level: t.Optional[int] = None) -> None:
+        def print_schema(
+            column_name: str, column_type: exp.DataType, nullable: bool, current_level: int
+        ):
+            if level and current_level >= level:
+                return
+            if current_level > 0:
+                print(" |   " * current_level, end="")
+            print(
+                f" |-- {column_name}: {column_type.sql(self.session.output_dialect).lower()} (nullable = {str(nullable).lower()})"
+            )
+            if column_type.this == exp.DataType.Type.STRUCT:
+                for column_def in column_type.expressions:
+                    print_schema(column_def.name, column_def.args["kind"], True, current_level + 1)
+            if column_type.this == exp.DataType.Type.ARRAY:
+                for data_type in column_type.expressions:
+                    print_schema("element", data_type, True, current_level + 1)
+            if column_type.this == exp.DataType.Type.MAP:
+                print_schema("key", column_type.expressions[0], True, current_level + 1)
+                print_schema("value", column_type.expressions[1], True, current_level + 1)
+
+        columns = self._get_columns_from_temp_object()
+        print("root")
+        for column in columns:
+            print_schema(
+                column.name,
+                exp.DataType.build(column.dataType, dialect=self.session.output_dialect),
+                column.nullable,
+                0,
+            )