Edit on GitHub

sqlglot.optimizer.normalize_identifiers

 1from __future__ import annotations
 2
 3import typing as t
 4
 5from sqlglot import ParseError, exp, parse_one
 6from sqlglot._typing import E
 7from sqlglot.dialects.dialect import Dialect, DialectType
 8
 9
10@t.overload
11def normalize_identifiers(expression: E, dialect: DialectType = None) -> E:
12    ...
13
14
15@t.overload
16def normalize_identifiers(expression: str, dialect: DialectType = None) -> exp.Expression:
17    ...
18
19
20def normalize_identifiers(expression, dialect=None):
21    """
22    Normalize all unquoted identifiers to either lower or upper case, depending
23    on the dialect. This essentially makes those identifiers case-insensitive.
24
25    It's possible to make this a no-op by adding a special comment next to the
26    identifier of interest:
27
28        SELECT a /* sqlglot.meta case_sensitive */ FROM table
29
30    In this example, the identifier `a` will not be normalized.
31
32    Note:
33        Some dialects (e.g. BigQuery) treat identifiers as case-insensitive even
34        when they're quoted, so in these cases all identifiers are normalized.
35
36    Example:
37        >>> import sqlglot
38        >>> expression = sqlglot.parse_one('SELECT Bar.A AS A FROM "Foo".Bar')
39        >>> normalize_identifiers(expression).sql()
40        'SELECT bar.a AS a FROM "Foo".bar'
41        >>> normalize_identifiers("foo", dialect="snowflake").sql(dialect="snowflake")
42        'FOO'
43
44    Args:
45        expression: The expression to transform.
46        dialect: The dialect to use in order to decide how to normalize identifiers.
47
48    Returns:
49        The transformed expression.
50    """
51    if isinstance(expression, str):
52        try:
53            expression = parse_one(expression, dialect=dialect, into=exp.Identifier)
54        except ParseError:
55            expression = exp.to_identifier(expression)
56
57    dialect = Dialect.get_or_raise(dialect)
58
59    def _normalize(node: E) -> E:
60        if not node.meta.get("case_sensitive"):
61            exp.replace_children(node, _normalize)
62            node = dialect.normalize_identifier(node)
63        return node
64
65    return _normalize(expression)
def normalize_identifiers(expression, dialect=None):
21def normalize_identifiers(expression, dialect=None):
22    """
23    Normalize all unquoted identifiers to either lower or upper case, depending
24    on the dialect. This essentially makes those identifiers case-insensitive.
25
26    It's possible to make this a no-op by adding a special comment next to the
27    identifier of interest:
28
29        SELECT a /* sqlglot.meta case_sensitive */ FROM table
30
31    In this example, the identifier `a` will not be normalized.
32
33    Note:
34        Some dialects (e.g. BigQuery) treat identifiers as case-insensitive even
35        when they're quoted, so in these cases all identifiers are normalized.
36
37    Example:
38        >>> import sqlglot
39        >>> expression = sqlglot.parse_one('SELECT Bar.A AS A FROM "Foo".Bar')
40        >>> normalize_identifiers(expression).sql()
41        'SELECT bar.a AS a FROM "Foo".bar'
42        >>> normalize_identifiers("foo", dialect="snowflake").sql(dialect="snowflake")
43        'FOO'
44
45    Args:
46        expression: The expression to transform.
47        dialect: The dialect to use in order to decide how to normalize identifiers.
48
49    Returns:
50        The transformed expression.
51    """
52    if isinstance(expression, str):
53        try:
54            expression = parse_one(expression, dialect=dialect, into=exp.Identifier)
55        except ParseError:
56            expression = exp.to_identifier(expression)
57
58    dialect = Dialect.get_or_raise(dialect)
59
60    def _normalize(node: E) -> E:
61        if not node.meta.get("case_sensitive"):
62            exp.replace_children(node, _normalize)
63            node = dialect.normalize_identifier(node)
64        return node
65
66    return _normalize(expression)

Normalize all unquoted identifiers to either lower or upper case, depending on the dialect. This essentially makes those identifiers case-insensitive.

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. BigQuery) treat 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'
Arguments:
  • expression: The expression to transform.
  • dialect: The dialect to use in order to decide how to normalize identifiers.
Returns:

The transformed expression.