sqlglot.optimizer.normalize_identifiers

 1from __future__ import annotations
 2
 3import typing as t
 4
 5from sqlglot import exp
 6from sqlglot.dialects.dialect import Dialect, DialectType
 7
 8if t.TYPE_CHECKING:
 9    from sqlglot._typing import E
10
11
12@t.overload
13def normalize_identifiers(
14    expression: E, dialect: DialectType = None, store_original_column_identifiers: bool = False
15) -> E: ...
16
17
18@t.overload
19def normalize_identifiers(
20    expression: str, dialect: DialectType = None, store_original_column_identifiers: bool = False
21) -> exp.Identifier: ...
22
23
24def normalize_identifiers(expression, dialect=None, store_original_column_identifiers=False):
25    """
26    Normalize identifiers by converting them to either lower or upper case,
27    ensuring the semantics are preserved in each case (e.g. by respecting
28    case-sensitivity).
29
30    This transformation reflects how identifiers would be resolved by the engine corresponding
31    to each SQL dialect, and plays a very important role in the standardization of the AST.
32
33    It's possible to make this a no-op by adding a special comment next to the
34    identifier of interest:
35
36        SELECT a /* sqlglot.meta case_sensitive */ FROM table
37
38    In this example, the identifier `a` will not be normalized.
39
40    Note:
41        Some dialects (e.g. DuckDB) treat all identifiers as case-insensitive even
42        when they're quoted, so in these cases all identifiers are normalized.
43
44    Example:
45        >>> import sqlglot
46        >>> expression = sqlglot.parse_one('SELECT Bar.A AS A FROM "Foo".Bar')
47        >>> normalize_identifiers(expression).sql()
48        'SELECT bar.a AS a FROM "Foo".bar'
49        >>> normalize_identifiers("foo", dialect="snowflake").sql(dialect="snowflake")
50        'FOO'
51
52    Args:
53        expression: The expression to transform.
54        dialect: The dialect to use in order to decide how to normalize identifiers.
55        store_original_column_identifiers: Whether to store the original column identifiers in
56            the meta data of the expression in case we want to undo the normalization at a later point.
57
58    Returns:
59        The transformed expression.
60    """
61    dialect = Dialect.get_or_raise(dialect)
62
63    if isinstance(expression, str):
64        expression = exp.parse_identifier(expression, dialect=dialect)
65
66    for node in expression.walk(prune=lambda n: n.meta.get("case_sensitive")):
67        if not node.meta.get("case_sensitive"):
68            if store_original_column_identifiers and isinstance(node, exp.Column):
69                # TODO: This does not handle non-column cases, e.g PARSE_JSON(...).key
70                parent = node
71                while parent and isinstance(parent.parent, exp.Dot):
72                    parent = parent.parent
73
74                node.meta["dot_parts"] = [p.name for p in parent.parts]
75
76            dialect.normalize_identifier(node)
77
78    return expression