Edit on GitHub

sqlglot.optimizer.normalize_identifiers 

 1from __future__ import annotations
 2
 3import typing as t
 4
 5from sqlglot import exp
 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        expression = exp.to_identifier(expression)
53
54    dialect = Dialect.get_or_raise(dialect)
55
56    def _normalize(node: E) -> E:
57        if not node.meta.get("case_sensitive"):
58            exp.replace_children(node, _normalize)
59            node = dialect.normalize_identifier(node)
60        return node
61
62    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        expression = exp.to_identifier(expression)
54
55    dialect = Dialect.get_or_raise(dialect)
56
57    def _normalize(node: E) -> E:
58        if not node.meta.get("case_sensitive"):
59            exp.replace_children(node, _normalize)
60            node = dialect.normalize_identifier(node)
61        return node
62
63    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.