Repository navigation
Expand file tree
/
Copy path__init__.py
More file actions
202 lines (167 loc) · 6.01 KB
/
Copy path__init__.py
File metadata and controls
202 lines (167 loc) · 6.01 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
# ruff: noqa: F401
"""
.. include:: ../README.md
----
"""
from __future__ import annotations
from collections.abc import Collection
from builtins import type as Type
import logging
import typing as t
from sqlglot import expressions as exp
from sqlglot.dialects.dialect import Dialect as Dialect, Dialects as Dialects
from sqlglot.diff import diff as diff
from sqlglot.errors import (
ErrorLevel as ErrorLevel,
ParseError as ParseError,
TokenError as TokenError,
UnsupportedError as UnsupportedError,
)
from sqlglot.expressions import (
Expr as Expr,
alias_ as alias,
and_ as and_,
case as case,
cast as cast,
column as column,
condition as condition,
delete as delete,
except_ as except_,
find_tables as find_tables,
from_ as from_,
func as func,
insert as insert,
intersect as intersect,
maybe_parse as maybe_parse,
merge as merge,
not_ as not_,
or_ as or_,
select as select,
subquery as subquery,
table_ as table,
to_column as to_column,
to_identifier as to_identifier,
to_table as to_table,
union as union,
)
from sqlglot.generator import Generator as Generator
from sqlglot.parser import Parser as Parser
from sqlglot.schema import MappingSchema as MappingSchema, Schema as Schema
from sqlglot.tokens import Token as Token, Tokenizer as Tokenizer, TokenType as TokenType
if t.TYPE_CHECKING:
from sqlglot._typing import E, GeneratorArgs, ParserNoDialectArgs
from typing_extensions import Unpack
from sqlglot.dialects.dialect import DialectType as DialectType
logger = logging.getLogger("sqlglot")
try:
from sqlglot._version import __version__, __version_tuple__ # type: ignore[import-not-found]
except ImportError:
logger.error(
"Unable to set __version__, run `pip install -e .` or `python setup.py develop` first."
)
pretty = False
"""Whether to format generated SQL by default."""
def tokenize(sql: str, read: DialectType = None, dialect: DialectType = None) -> list[Token]:
"""
Tokenizes the given SQL string.
Args:
sql: the SQL code string to tokenize.
read: the SQL dialect to apply during tokenizing (eg. "spark", "hive", "presto", "mysql").
See `sqlglot.dialects.Dialects` for options.
dialect: the SQL dialect (alias for read).
Returns:
The resulting list of tokens.
"""
return Dialect.get_or_raise(read or dialect).tokenize(sql)
def parse(
sql: str,
read: DialectType = None,
dialect: DialectType = None,
**opts: Unpack[ParserNoDialectArgs],
) -> list[Expr | None]:
"""
Parses the given SQL string into a collection of syntax trees, one per parsed SQL statement.
Args:
sql: the SQL code string to parse.
read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
See `sqlglot.dialects.Dialects` for options.
dialect: the SQL dialect (alias for read).
**opts: other `sqlglot.parser.Parser` options.
Returns:
The resulting syntax tree collection.
"""
return Dialect.get_or_raise(read or dialect).parse(sql, **opts)
@t.overload
def parse_one(
sql: str,
*,
read: DialectType = ...,
dialect: DialectType = ...,
into: Type[E],
**opts: Unpack[ParserNoDialectArgs],
) -> E: ...
@t.overload
def parse_one(
sql: str,
read: DialectType = ...,
dialect: DialectType = ...,
into: exp.IntoType | None = ...,
**opts: Unpack[ParserNoDialectArgs],
) -> Expr: ...
def parse_one(
sql: str,
read: DialectType = None,
dialect: DialectType = None,
into: exp.IntoType | None = None,
**opts: Unpack[ParserNoDialectArgs],
) -> Expr:
"""
Parses the given SQL string and returns a syntax tree.
Args:
sql: the SQL code string to parse.
read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
See `sqlglot.dialects.Dialects` for options.
dialect: the SQL dialect (alias for read)
into: the SQLGlot Expr to parse into.
**opts: other `sqlglot.parser.Parser` options.
Returns:
A single syntax tree if one statement is parsed, otherwise a Block expression containing all parsed syntax trees.
"""
dialect = Dialect.get_or_raise(read or dialect)
if into:
result = dialect.parse_into(into, sql, **opts)
else:
result = dialect.parse(sql, **opts)
if not result or result[0] is None:
raise ParseError(f"No expression was parsed from '{sql}'")
return exp.Block(expressions=result) if len(result) > 1 else result[0]
def transpile(
sql: str,
read: DialectType = None,
write: DialectType = None,
identity: bool = True,
error_level: ErrorLevel | None = None,
**opts: Unpack[GeneratorArgs],
) -> list[str]:
"""
Parses the given SQL string in accordance with the source dialect and returns a list of SQL strings transformed
to conform to the target dialect. Each string in the returned list represents a single transformed SQL statement.
Args:
sql: the SQL code string to transpile.
read: the source dialect used to parse the input string (eg. "spark", "hive", "presto", "mysql").
See `sqlglot.dialects.Dialects` for options.
write: the target dialect into which the input should be transformed (eg. "spark", "hive", "presto", "mysql").
See `sqlglot.dialects.Dialects` for options.
identity: if set to `True` and if the target dialect is not specified the source dialect will be used as both:
the source and the target dialect.
error_level: the desired error level of the parser.
**opts: other `sqlglot.generator.Generator` options.
Returns:
The list of transpiled SQL statements.
"""
write = (read if write is None else write) if identity else write
write = Dialect.get_or_raise(write)
return [
write.generate(expression, copy=False, **opts) if expression else ""
for expression in parse(sql, read, error_level=error_level)
]