sqlframe 0.1.dev3__tar.gz

sqlframe-0.1.dev3/.gitignore

@@ -0,0 +1,145 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# PyCharm
+.idea/
+
+# Visual Studio Code
+.vscode
+
+.DS_STORE
+metastore_db
+spark_warehouse
+
+# Version file
+sqlframe/_version.py
+
+# Emacs files
+*~

sqlframe-0.1.dev3/.pre-commit-config.yaml

@@ -0,0 +1,33 @@
+repos:
+  - repo: local
+    hooks:
+      - id: ruff
+        name: ruff
+        description: "Run 'ruff' for extremely fast Python linting"
+        entry: ruff check
+            --force-exclude 
+            --fix
+            --select I
+            --ignore E721
+            --ignore E741
+        language: python
+        types_or: [python, pyi]
+        require_serial: true
+        additional_dependencies: []
+        files: ^(sqlframe/|tests/|setup.py)
+      - id: ruff-format
+        name: ruff-format
+        description: "Run 'ruff format' for extremely fast Python formatting"
+        entry: ruff format
+          --force-exclude
+          --line-length 100
+        language: python
+        types_or: [python, pyi]
+        require_serial: true
+      - id: mypy
+        name: mypy
+        entry: mypy sqlframe tests
+        language: system
+        types: [ python ]
+        files: ^(sqlframe/|tests/)
+        pass_filenames: false

sqlframe-0.1.dev3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ryan Eakman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlframe-0.1.dev3/Makefile

@@ -0,0 +1,37 @@
+install-dev:
+	pip install -e ".[dev]"
+
+install-pre-commit:
+	pre-commit install
+
+slow-test:
+	pytest -n auto tests
+
+fast-test:
+	pytest -n auto tests/unit
+
+local-test:
+	pytest -n auto -m "local"
+
+bigquery-test:
+	pytest -n auto -m "bigquery"
+
+duckdb-test:
+	pytest -n auto -m "duckdb"
+
+style:
+	pre-commit run --all-files
+
+docs-serve:
+	mkdocs serve
+
+stubs:
+	stubgen sqlframe/bigquery/functions.py --output ./ --inspect-mode
+	stubgen sqlframe/duckdb/functions.py --output ./ --inspect-mode
+	stubgen sqlframe/postgres/functions.py --output ./ --inspect-mode
+
+package:
+	pip3 install wheel && python3 setup.py sdist bdist_wheel
+
+publish: package
+	pip3 install twine && python3 -m twine upload dist/*

sqlframe-0.1.dev3/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.1
+Name: sqlframe
+Version: 0.1.dev3
+Summary: PySpark Dataframe API Compatible SQL Generator
+Home-page: https://github.com/eakmanrq/sqlframe
+Author: Ryan Eakman
+Author-email: eakmanrq@gmail.com
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: SQL
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: prettytable
+Requires-Dist: sqlglot
+Provides-Extra: bigquery
+Requires-Dist: google-cloud-bigquery[pandas]; extra == "bigquery"
+Requires-Dist: google-cloud-bigquery-storage; extra == "bigquery"
+Provides-Extra: dev
+Requires-Dist: duckdb; extra == "dev"
+Requires-Dist: mkdocs==1.4.2; extra == "dev"
+Requires-Dist: mkdocs-include-markdown-plugin==4.0.3; extra == "dev"
+Requires-Dist: mkdocs-material==9.0.5; extra == "dev"
+Requires-Dist: mkdocs-material-extensions==1.1.1; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pandas; extra == "dev"
+Requires-Dist: pymdown-extensions; extra == "dev"
+Requires-Dist: psycopg; extra == "dev"
+Requires-Dist: pyarrow; extra == "dev"
+Requires-Dist: pyspark; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-postgresql; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Requires-Dist: types-psycopg2; extra == "dev"
+Provides-Extra: duckdb
+Requires-Dist: duckdb; extra == "duckdb"
+Requires-Dist: pandas; extra == "duckdb"
+Provides-Extra: postgres
+Requires-Dist: psycopg2; extra == "postgres"
+Provides-Extra: redshift
+Requires-Dist: redshift_connector; extra == "redshift"
+Provides-Extra: snowflake
+Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra == "snowflake"
+Provides-Extra: spark
+Requires-Dist: pyspark; extra == "spark"
+
+<div align="center">
+  <img src="docs/images/sqlframe_logo.png" alt="SQLFrame Logo" width="400"/>
+</div>
+
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+SQLFrame implements the PySpark DataFrame API in order to enable running transformation pipelines directly on database engines - no Spark clusters or dependencies required.
+
+![SQLFrame Diagram](docs/images/sqlframe_diagram.png)
+
+SQLFrame currently supports the following engines:
+
+* [BigQuery](docs/bigquery.md)
+* [DuckDB](docs/duckdb.md)
+* [Postgres](docs/postgres.md)
+
+SQLFrame also has a "Standalone" session that be used to generate SQL without any connection to a database engine.
+* [Standalone](docs/standalone.md)
+
+SQLFrame is great for:
+
+* Users who want to run PySpark DataFrame code without having to use a Spark cluster
+* Users who want a SQL representation of their DataFrame code for debugging or sharing with others
+* Users who want a DataFrame API that leverages the full power of their engine to do the processing 
+
+## Installation
+
+```bash
+# BigQuery
+pip install "sqlframe[bigquery]"
+# DuckDB
+pip install "sqlframe[duckdb]"
+# Postgres
+pip install "sqlframe[postgres]"
+# Standalone
+pip install sqlframe
+```
+
+See specific engine documentation for additional setup instructions.
+
+## Example Usage
+
+```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"
+# Get the top 5 years with the greatest year-over-year % change in new families with a 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("number of new families single child"),
+        F.format_number(F.col("percent_change") * 100, 2).alias("percent change"),
+    )
+    .limit(5)
+)
+```
+```python
+df.sql()
+```
+```sql
+WITH `t94228` 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`
+), `t39093` AS (
+  SELECT
+    `t94228`.`year` AS `year`,
+    `t94228`.`num_single_child_families` AS `num_single_child_families`,
+    LAG(`t94228`.`num_single_child_families`, 1) OVER (ORDER BY `t94228`.`year`) AS `last_year_num_single_child_families`
+  FROM `t94228` AS `t94228`
+)
+SELECT
+  `t39093`.`year` AS `year`,
+  FORMAT('%\'.0f', ROUND(CAST(`t39093`.`num_single_child_families` AS FLOAT64), 0)) AS `number of new families single child`,
+  FORMAT('%\'.2f', ROUND(CAST((((`t39093`.`num_single_child_families` - `t39093`.`last_year_num_single_child_families`) / `t39093`.`last_year_num_single_child_families`) * 100) AS FLOAT64), 2)) AS `percent change`
+FROM `t39093` AS `t39093`
+ORDER BY
+  ABS(`percent_change`) DESC
+LIMIT 5
+```
+```python
+df.show()
+```
+```
++------+-------------------------------------+----------------+
+| year | number of new families single child | percent change |
++------+-------------------------------------+----------------+
+| 1989 |              1,650,246              |     25.02      |
+| 1974 |               783,448               |     14.49      |
+| 1977 |              1,057,379              |     11.38      |
+| 1985 |              1,308,476              |     11.15      |
+| 1975 |               868,985               |     10.92      |
++------+-------------------------------------+----------------+
+```

sqlframe-0.1.dev3/README.md

@@ -0,0 +1,116 @@
+<div align="center">
+  <img src="docs/images/sqlframe_logo.png" alt="SQLFrame Logo" width="400"/>
+</div>
+
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+SQLFrame implements the PySpark DataFrame API in order to enable running transformation pipelines directly on database engines - no Spark clusters or dependencies required.
+
+![SQLFrame Diagram](docs/images/sqlframe_diagram.png)
+
+SQLFrame currently supports the following engines:
+
+* [BigQuery](docs/bigquery.md)
+* [DuckDB](docs/duckdb.md)
+* [Postgres](docs/postgres.md)
+
+SQLFrame also has a "Standalone" session that be used to generate SQL without any connection to a database engine.
+* [Standalone](docs/standalone.md)
+
+SQLFrame is great for:
+
+* Users who want to run PySpark DataFrame code without having to use a Spark cluster
+* Users who want a SQL representation of their DataFrame code for debugging or sharing with others
+* Users who want a DataFrame API that leverages the full power of their engine to do the processing 
+
+## Installation
+
+```bash
+# BigQuery
+pip install "sqlframe[bigquery]"
+# DuckDB
+pip install "sqlframe[duckdb]"
+# Postgres
+pip install "sqlframe[postgres]"
+# Standalone
+pip install sqlframe
+```
+
+See specific engine documentation for additional setup instructions.
+
+## Example Usage
+
+```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"
+# Get the top 5 years with the greatest year-over-year % change in new families with a 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("number of new families single child"),
+        F.format_number(F.col("percent_change") * 100, 2).alias("percent change"),
+    )
+    .limit(5)
+)
+```
+```python
+df.sql()
+```
+```sql
+WITH `t94228` 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`
+), `t39093` AS (
+  SELECT
+    `t94228`.`year` AS `year`,
+    `t94228`.`num_single_child_families` AS `num_single_child_families`,
+    LAG(`t94228`.`num_single_child_families`, 1) OVER (ORDER BY `t94228`.`year`) AS `last_year_num_single_child_families`
+  FROM `t94228` AS `t94228`
+)
+SELECT
+  `t39093`.`year` AS `year`,
+  FORMAT('%\'.0f', ROUND(CAST(`t39093`.`num_single_child_families` AS FLOAT64), 0)) AS `number of new families single child`,
+  FORMAT('%\'.2f', ROUND(CAST((((`t39093`.`num_single_child_families` - `t39093`.`last_year_num_single_child_families`) / `t39093`.`last_year_num_single_child_families`) * 100) AS FLOAT64), 2)) AS `percent change`
+FROM `t39093` AS `t39093`
+ORDER BY
+  ABS(`percent_change`) DESC
+LIMIT 5
+```
+```python
+df.show()
+```
+```
++------+-------------------------------------+----------------+
+| year | number of new families single child | percent change |
++------+-------------------------------------+----------------+
+| 1989 |              1,650,246              |     25.02      |
+| 1974 |               783,448               |     14.49      |
+| 1977 |              1,057,379              |     11.38      |
+| 1985 |              1,308,476              |     11.15      |
+| 1975 |               868,985               |     10.92      |
++------+-------------------------------------+----------------+
+```

sqlframe-0.1.dev3/blogs/sqlframe_universal_dataframe_api.md

@@ -0,0 +1,139 @@
+# SQLFrame: Turning PySpark into a Universal DataFrame API
+## Have your SQL/Python Cake and Eat it Too
+
+After 13 years as a data engineer, I've grown accustomed to constant change - whether significant shifts like the move to the cloud or smaller trends like the rise of notebooks. 
+Amid all this change, one thing has remained constant: SQL. 
+Every job I've had, from startups to FAANG, has leveraged the fact that I both understand and write SQL. 
+SQL is the universal language that unites all data professionals, and it enables performant pipelines by allowing query planners and optimizers to handle complex details of distributed processing.
+
+Despite its strengths, SQL often seems ill-suited for maintaining data pipelines.
+The language lacks support for abstracting common operations or unit testing specific segments of code, leading many to use Jinja as a makeshift solution. 
+Jinja SQL is to SQL what Pig Latin is to English - can be fun in small doses but impossible to understand at scale. 
+Moreover, SQL's repetitive nature, requiring columns to be repeated across operations, leads to fatigue and many data practitioners responding to the siren song of `SELECT *` and later found drowning in the sea of non-determinism.
+
+This has put data professionals in a tough spot: Do you write your pipelines in SQL to favor accessibility or Python to favor maintainability? 
+Well, starting today, you no longer have to choose. 
+You can finally have your cake and eat it too.
+
+<div align="center">
+  <img src="images/cake.gif" alt="Bruce Bogtrotter" width="800"/>
+</div>
+
+### Introducing open-source SQLFrame!
+
+<div align="center">
+  <img src="../docs/images/sqlframe_logo.png" alt="SQLFrame Logo" width="800"/>
+</div>
+
+SQLFrame revolutionizes how data professionals interact with SQL and PySpark DataFrames. 
+Unlike traditional PySpark, SQLFrame converts DataFrame operations directly into SQL, enabling real-time SQL script generation during development. 
+Here's how it works:
+
+Consider a scenario where we analyze the number of new families per year choosing to have a single child based on publicly accessible natality data.
+
+```python
+from sqlframe.bigquery import BigQuerySession
+from sqlframe.bigquery import functions as F
+from sqlframe.bigquery import Window
+
+# Unique to SQLFrame: Ability to connect directly to BigQuery
+session = BigQuerySession()
+table_path = "bigquery-public-data.samples.natality"
+# Get the top 5 years with the greatest year-over-year % change in new families with a 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("number of new families single child"),
+        F.format_number(F.col("percent_change") * 100, 2).alias("percent change"),
+    )
+    .limit(5)
+)
+# Unique to SQLFrame: Ability to see the SQL for your DataFrame
+df.sql()
+```
+
+Using SQLFrame, you can utilize the special BigQuery class to seamlessly integrate with your BigQuery environment. 
+The DataFrame operations mimic those you'd perform in PySpark, but with SQLFrame, you can also generate and review the corresponding SQL queries in real time using the `df.sql()` method.
+
+```sql
+WITH `t94228` 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`
+), `t39093` AS (
+  SELECT
+    `t94228`.`year` AS `year`,
+    `t94228`.`num_single_child_families` AS `num_single_child_families`,
+    LAG(`t94228`.`num_single_child_families`, 1) OVER (ORDER BY `t94228`.`year`) AS `last_year_num_single_child_families`
+  FROM `t94228` AS `t94228`
+)
+SELECT
+  `t39093`.`year` AS `year`,
+  FORMAT('%\'.0f', ROUND(CAST(`t39093`.`num_single_child_families` AS FLOAT64), 0)) AS `number of new families single child`,
+  FORMAT('%\'.2f', ROUND(CAST((((`t39093`.`num_single_child_families` - `t39093`.`last_year_num_single_child_families`) / `t39093`.`last_year_num_single_child_families`) * 100) AS FLOAT64), 2)) AS `percent change`
+FROM `t39093` AS `t39093`
+ORDER BY
+  ABS(`percent_change`) DESC
+LIMIT 5
+```
+
+This feature not only enhances understanding but also ensures that the SQL output is deterministic, making it suitable for version control. 
+That way you can version both the Python and SQL representation of your pipelines and let your co-workers pick which format best suits them!
+
+<div align="center">
+  <img src="images/but_wait_theres_more.gif" alt="There is more" width="800"/>
+</div>
+
+SQLFrame though is much more than just generating SQL: the goal is to make the PySpark DataFrame API feel like a native DataFrame API on all major data warehouses. 
+Therefore it enables users to execute DataFrame API pipelines directly on their data warehouse without any Spark clusters or libraries!
+
+For instance, replacing `.sql()` with `.show()` in your pipeline displays the results directly from BigQuery, just as it would in PySpark.
+
+```text
+>>> df.show()
++------+-------------------------------------+----------------+
+| year | number of new families single child | percent change |
++------+-------------------------------------+----------------+
+| 1989 |              1,650,246              |     25.02      |
+| 1974 |               783,448               |     14.49      |
+| 1977 |              1,057,379              |     11.38      |
+| 1985 |              1,308,476              |     11.15      |
+| 1975 |               868,985               |     10.92      |
++------+-------------------------------------+----------------+
+```
+
+Even many of the Catalog operations are supported like `listColumns`:
+
+```text
+>>> columns = session.catalog.listColumns(table_path)
+>>> print("\n".join([f"Name: {x.name}, Data Type: {x.dataType}, Desc: {x.description}" for x in columns]))
+Name: source_year, Data Type: INT64, Desc: Four-digit year of the birth. Example: 1975.
+Name: year, Data Type: INT64, Desc: Four-digit year of the birth. Example: 1975.
+Name: month, Data Type: INT64, Desc: Month index of the date of birth, where 1=January.
+Name: day, Data Type: INT64, Desc: Day of birth, starting from 1.
+Name: wday, Data Type: INT64, Desc: Day of the week, where 1 is Sunday and 7 is Saturday.
+Name: state, Data Type: STRING, Desc: The two character postal code for the state. Entries after 2004 do not include this value.
+```
+
+Therefore not only does SQLFrame make your DataFrame pipeline more accessible, it also turns the PySpark DataFrame API in universal DataFrame API that any data practitioner can enjoy!
+
+<div align="center">
+  <img src="images/you_get_pyspark_api.gif" alt="There is more" width="800"/>
+</div>
+
+SQLFrame currently supports BigQuery, DuckDB, and PostgreSQL, with Redshift, Snowflake, Spark, and Trino in development. 
+For those interested in experimenting with SQL generation for other engines, the "StandaloneSession" provides a flexible testing ground.
+
+Follow the simple setup guide to begin integrating SQLFrame into your projects today!