An easily customizable SQL parser and transpiler
Project description
SQLGlot
SQLGlot is a no dependency Python SQL parser, transpiler, and optimizer. It can be used to format SQL or translate between different dialects like DuckDB, Presto, Spark, and BigQuery. It aims to read a wide variety of SQL inputs and output syntatically correct SQL in the targeted dialects.
It is a very comprehensive generic SQL parser with a robust test suite. It is also quite performant while being written purely in Python.
You can easily customize the parser, analyze queries, traverse expression trees, and programmatically build SQL.
Syntax errors are highlighted and dialect incompatibilities can warn or raise depending on configurations.
Install
From PyPI
pip3 install sqlglot
Or with a local checkout
pip3 install -e .
Examples
Easily translate from one dialect to another. For example, date/time functions vary from dialects and can be hard to deal with.
import sqlglot
sqlglot.transpile("SELECT EPOCH_MS(1618088028295)", read='duckdb', write='hive')
SELECT TO_UTC_TIMESTAMP(FROM_UNIXTIME(1618088028295 / 1000, 'yyyy-MM-dd HH:mm:ss'), 'UTC')
SQLGlot can even translate custom time formats.
import sqlglot
sqlglot.transpile("SELECT STRFTIME(x, '%y-%-m-%S')", read='duckdb', write='hive')
SELECT DATE_FORMAT(x, 'yy-M-ss')"
Formatting and Transpiling
Read in a SQL statement with a CTE and CASTING to a REAL and then transpiling to Spark.
Spark uses backticks as identifiers and the REAL type is transpiled to FLOAT.
import sqlglot
sql = """WITH baz AS (SELECT a, c FROM foo WHERE a = 1) SELECT f.a, b.b, baz.c, CAST("b"."a" AS REAL) d FROM foo f JOIN bar b ON f.a = b.a LEFT JOIN baz ON f.a = baz.a"""
sqlglot.transpile(sql, write='spark', identify=True, pretty=True)[0]
WITH `baz` AS (
SELECT
`a`,
`c`
FROM `foo`
WHERE
`a` = 1
)
SELECT
`f`.`a`,
`b`.`b`,
`baz`.`c`,
CAST(`b`.`a` AS FLOAT) AS `d`
FROM `foo` AS `f`
JOIN `bar` AS `b`
ON `f`.`a` = `b`.`a`
LEFT JOIN `baz`
ON `f`.`a` = `baz`.`a`
Metadata
You can explore SQL with expression helpers to do things like find columns and tables.
from sqlglot import parse_one, exp
# print all column references (a and b)
for column in parse_one("SELECT a, b + 1 AS c FROM d").find_all(exp.Column):
print(column.alias_or_name)
# find all projections in select statements (a and c)
for select in parse_one("SELECT a, b + 1 AS c FROM d").find_all(exp.Select):
for projection in select.expressions:
print(projection.alias_or_name)
# find all tables (x, y, z)
for table in parse_one("SELECT * FROM x JOIN y JOIN z").find_all(exp.Table):
print(table.name)
Parser Errors
A syntax error will result in a parser error.
transpile("SELECT foo( FROM bar")
sqlglot.errors.ParseError: Expecting ). Line 1, Col: 13. select foo( FROM bar
Unsupported Errors
Presto APPROX_DISTINCT supports the accuracy argument which is not supported in Spark.
transpile(
'SELECT APPROX_DISTINCT(a, 0.1) FROM foo',
read='presto',
write='spark',
)
WARNING:root:APPROX_COUNT_DISTINCT does not support accuracy
SELECT APPROX_COUNT_DISTINCT(a) FROM foo
Build and Modify SQL
SQLGlot supports incrementally building sql expressions.
from sqlglot import select, condition
where = condition("x=1").and_("y=1")
select("*").from_("y").where(where).sql()
Which outputs:
SELECT * FROM y WHERE x = 1 AND y = 1
You can also modify a parsed tree:
from sqlglot import parse_one
parse_one("SELECT x FROM y").from_("z").sql()
Which outputs:
SELECT x FROM y, z
There is also a way to recursively transform the parsed tree by applying a mapping function to each tree node:
from sqlglot import exp, parse_one
expression_tree = parse_one("SELECT a FROM x")
def transformer(node):
if isinstance(node, exp.Column) and node.name == "a":
return parse_one("FUN(a)")
return node
transformed_tree = expression_tree.transform(transformer)
transformed_tree.sql()
Which outputs:
SELECT FUN(a) FROM x
SQL Optimizer
SQLGlot can rewrite queries into an "optimized" form. It performs a variety of techniques to create a new canonical AST. This AST can be used to standaradize queries or provide the foundations for implementing an actual engine.
import sqlglot
from sqlglot.optimizer import optimize
>>>
optimize(
sqlglot.parse_one("""
SELECT A OR (B OR (C AND D))
FROM x
WHERE Z = date '2021-01-01' + INTERVAL '1' month OR 1 = 0
"""),
schema={"x": {"A": "INT", "B": "INT", "C": "INT", "D": "INT", "Z": "STRING"}}
).sql(pretty=True)
"""
SELECT
(
"x"."A"
OR "x"."B"
OR "x"."C"
)
AND (
"x"."A"
OR "x"."B"
OR "x"."D"
) AS "_col_0"
FROM "x" AS "x"
WHERE
"x"."Z" = CAST('2021-02-01' AS DATE)
"""
SQL Annotations
SQLGlot supports annotations in the sql expression. This is an experimental feature that is not part of any of the SQL standards but it can be useful when needing to annotate what a selected field is supposed to be. Below is an example:
SELECT
user #primary_key,
country
FROM users
AST Introspection
You can see the AST version of the sql by calling repr.
from sqlglot import parse_one
repr(parse_one("SELECT a + 1 AS z"))
(SELECT expressions:
(ALIAS this:
(ADD this:
(COLUMN this:
(IDENTIFIER this: a, quoted: False)), expression:
(LITERAL this: 1, is_string: False)), alias:
(IDENTIFIER this: z, quoted: False)))
AST Diff
SQLGlot can calculate the difference between two expressions and output changes in a form of a sequence of actions needed to transform a source expression into a target one.
from sqlglot import diff, parse_one
diff(parse_one("SELECT a + b, c, d"), parse_one("SELECT c, a - b, d"))
[
Remove(expression=(ADD this:
(COLUMN this:
(IDENTIFIER this: a, quoted: False)), expression:
(COLUMN this:
(IDENTIFIER this: b, quoted: False)))),
Insert(expression=(SUB this:
(COLUMN this:
(IDENTIFIER this: a, quoted: False)), expression:
(COLUMN this:
(IDENTIFIER this: b, quoted: False)))),
Move(expression=(COLUMN this:
(IDENTIFIER this: c, quoted: False))),
Keep(source=(IDENTIFIER this: b, quoted: False), target=(IDENTIFIER this: b, quoted: False)),
...
]
Custom Dialects
Dialects can be added by subclassing Dialect.
from sqlglot import exp
from sqlglot.dialects.dialect import Dialect
from sqlglot.generator import Generator
from sqlglot.tokens import Tokenizer, TokenType
class Custom(Dialect):
identifier = "`"
class Tokenizer(Tokenizer):
QUOTES = ["'", '"']
KEYWORDS = {
**Tokenizer.KEYWORDS,
"INT64": TokenType.BIGINT,
"FLOAT64": TokenType.DOUBLE,
}
class Generator(Generator):
TRANSFORMS = {exp.Array: lambda self, e: f"[{self.expressions(e)}]"}
TYPE_MAPPING = {
exp.DataType.Type.TINYINT: "INT64",
exp.DataType.Type.SMALLINT: "INT64",
exp.DataType.Type.INT: "INT64",
exp.DataType.Type.BIGINT: "INT64",
exp.DataType.Type.DECIMAL: "NUMERIC",
exp.DataType.Type.FLOAT: "FLOAT64",
exp.DataType.Type.DOUBLE: "FLOAT64",
exp.DataType.Type.BOOLEAN: "BOOL",
exp.DataType.Type.TEXT: "STRING",
}
Dialects["custom"]
Benchmarks
Benchmarks run on Python 3.10.5 in seconds.
| Query | sqlglot | sqltree | sqlparse | moz_sql_parser | sqloxide |
|---|---|---|---|---|---|
| tpch | 0.01226 (1.0) | 0.01158 (0.944) | 0.04706 (3.837) | 0.07054 (5.751) | 0.00098 (0.080) |
| short | 0.00085 (1.0) | 0.00079 (0.932) | 0.00281 (3.293) | 0.00449 (5.259) | 0.00006 (0.074) |
| long | 0.01148 (1.0) | 0.00978 (0.851) | 0.04170 (3.629) | 0.06012 (5.233) | 0.00089 (0.077) |
| crazy | 0.03945 (1.0) | 0.03439 (0.871) | 11.9834 (303.7) | 1.06398 (26.96) | 0.00564 (0.143) |
Run Tests and Lint
pip install -r requirements.txt
./format_code.sh
./run_checks.sh
Optional Dependencies
SQLGlot uses dateutil to simplify literal timedelta expressions. The optimizer will not simplify expressions like
x + interval '1' month
if the module cannot be found.
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
File details
Details for the file sqlglot-4.2.2.tar.gz.
File metadata
- Download URL: sqlglot-4.2.2.tar.gz
- Upload date:
- Size: 79.5 kB
- Tags: Source
- Uploaded using Trusted Publishing? No
- Uploaded via: twine/4.0.1 CPython/3.9.13
File hashes
| Algorithm | Hash digest | |
|---|---|---|
| SHA256 | 3a3f61ce91a7e3d98ead31521cdc0212b4151afa43cca34178407e49919e61c7 |
|
| MD5 | 2b2d4d5b684a8c96e94daedac377f40b |
|
| BLAKE2b-256 | 48618460b43d0c5675d26f98635f48949d6f3b03ffaab210accfc3b69912afb4 |
Provenance
File details
Details for the file sqlglot-4.2.2-py3-none-any.whl.
File metadata
- Download URL: sqlglot-4.2.2-py3-none-any.whl
- Upload date:
- Size: 93.0 kB
- Tags: Python 3
- Uploaded using Trusted Publishing? No
- Uploaded via: twine/4.0.1 CPython/3.9.13
File hashes
| Algorithm | Hash digest | |
|---|---|---|
| SHA256 | 4a25b86249ff8a8008b7e32f8bc0bf95dc5b5544e8d3b632e19e45d415a9661f |
|
| MD5 | f0c44b7bd1d3c979795e129d81021324 |
|
| BLAKE2b-256 | 7a772a1588c5a2a967515e3862e9f3cc7f6d09a834944c59e5b1b09c8eda18e3 |
