Repository navigation
Expand file tree
/
Copy pathnormalize_identifiers.py
More file actions
79 lines (57 loc) · 2.83 KB
/
Copy pathnormalize_identifiers.py
File metadata and controls
79 lines (57 loc) · 2.83 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
from __future__ import annotations
import typing as t
from sqlglot import exp
from sqlglot.dialects.dialect import Dialect, DialectType
if t.TYPE_CHECKING:
from sqlglot._typing import E
@t.overload
def normalize_identifiers(
expression: E, dialect: DialectType = None, store_original_column_identifiers: bool = False
) -> E: ...
@t.overload
def normalize_identifiers(
expression: str, dialect: DialectType = None, store_original_column_identifiers: bool = False
) -> exp.Identifier: ...
def normalize_identifiers(expression, dialect=None, store_original_column_identifiers=False):
"""
Normalize identifiers by converting them to either lower or upper case,
ensuring the semantics are preserved in each case (e.g. by respecting
case-sensitivity).
This transformation reflects how identifiers would be resolved by the engine corresponding
to each SQL dialect, and plays a very important role in the standardization of the AST.
It's possible to make this a no-op by adding a special comment next to the
identifier of interest:
SELECT a /* sqlglot.meta case_sensitive */ FROM table
In this example, the identifier `a` will not be normalized.
Note:
Some dialects (e.g. DuckDB) treat all identifiers as case-insensitive even
when they're quoted, so in these cases all identifiers are normalized.
Example:
>>> import sqlglot
>>> expression = sqlglot.parse_one('SELECT Bar.A AS A FROM "Foo".Bar')
>>> normalize_identifiers(expression).sql()
'SELECT bar.a AS a FROM "Foo".bar'
>>> normalize_identifiers("foo", dialect="snowflake").sql(dialect="snowflake")
'FOO'
Args:
expression: The expression to transform.
dialect: The dialect to use in order to decide how to normalize identifiers.
store_original_column_identifiers: Whether to store the original column identifiers in
the meta data of the expression in case we want to undo the normalization at a later point.
Returns:
The transformed expression.
"""
dialect = Dialect.get_or_raise(dialect)
if isinstance(expression, str):
expression = exp.parse_identifier(expression, dialect=dialect)
for node in expression.walk(prune=lambda n: bool(n.meta_get("case_sensitive"))):
if not node.meta_get("case_sensitive"):
if store_original_column_identifiers and isinstance(node, exp.Column):
# TODO: This does not handle non-column cases, e.g PARSE_JSON(...).key
parent = node
while parent and isinstance(parent.parent, exp.Dot):
parent = parent.parent
node.meta["dot_parts"] = [p.name for p in parent.parts]
if isinstance(node, exp.Identifier):
dialect.normalize_identifier(node)
return expression