# sqlglot.optimizer.normalize_identifiers API documentation

Edit on GitHub

# sqlglot.optimizer.normalize_identifiers

View Source

     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(expression: E, dialect: DialectType = None) -> E: ...
    14
    15
    16@t.overload
    17def normalize_identifiers(expression: str, dialect: DialectType = None) -> exp.Identifier: ...
    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    dialect = Dialect.get_or_raise(dialect)
    52
    53    if isinstance(expression, str):
    54        expression = exp.parse_identifier(expression, dialect=dialect)
    55
    56    for node in expression.walk(prune=lambda n: n.meta.get("case_sensitive")):
    57        if not node.meta.get("case_sensitive"):
    58            dialect.normalize_identifier(node)
    59
    60    return expression

def normalize_identifiers(expression, dialect=None): View Source

    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    dialect = Dialect.get_or_raise(dialect)
    53
    54    if isinstance(expression, str):
    55        expression = exp.parse_identifier(expression, dialect=dialect)
    56
    57    for node in expression.walk(prune=lambda n: n.meta.get("case_sensitive")):
    58        if not node.meta.get("case_sensitive"):
    59            dialect.normalize_identifier(node)
    60
    61    return 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.